File indexing completed on 2024-04-28 16:55:00

 /*
     SPDX-FileCopyrightText: 2021 Cyril Rossi <cyril.rossi@enioka.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "shellcontainmentconfig.h"
 
 #include <KActionCollection>
 #include <KActivities/Consumer>
 #include <KActivities/Info>
 #include <KLocalizedContext>
 #include <KLocalizedString>
 #include <KPackage/Package>
 
 #include <QQmlContext>
 #include <QQuickItem>
 #include <QScreen>
 
 #include "panelview.h"
 #include "screenpool.h"
 #include "shellcorona.h"
 #include <chrono>
 
 using namespace std::chrono_literals;
 
 ScreenPoolModel::ScreenPoolModel(ShellCorona *corona, QObject *parent)
     : QAbstractListModel(parent)
     , m_corona(corona)
 {
     m_reloadTimer = new QTimer(this);
     m_reloadTimer->setSingleShot(true);
     m_reloadTimer->setInterval(200ms);
 
     connect(m_reloadTimer, &QTimer::timeout, this, &ScreenPoolModel::load);
 
     connect(m_corona, &Plasma::Corona::screenAdded, m_reloadTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
     connect(m_corona, &Plasma::Corona::screenRemoved, m_reloadTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
 }
 
 ScreenPoolModel::~ScreenPoolModel() = default;
 
 QVariant ScreenPoolModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.column() != 0 || index.row() < 0 || index.row() >= int(m_screens.size())) {
         return QVariant();
     }
     const Data &d = m_screens.at(index.row());
     switch (role) {
     case ScreenIdRole:
         return d.id;
     case ScreenNameRole:
         return d.name;
     case ContainmentsRole: {
         auto *cont = m_containments.at(index.row());
         return QVariant::fromValue<QObject *>(cont);
     }
     case PrimaryRole:
         return d.primary;
     case EnabledRole:
         return d.enabled;
     }
     return QVariant();
 }
 
 int ScreenPoolModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
     return m_screens.size();
 }
 
 QHash<int, QByteArray> ScreenPoolModel::roleNames() const
 {
     QHash<int, QByteArray> roles({{ScreenIdRole, QByteArrayLiteral("screenId")},
                                   {ScreenNameRole, QByteArrayLiteral("screenName")},
                                   {ContainmentsRole, QByteArrayLiteral("containments")},
                                   {EnabledRole, QByteArrayLiteral("isEnabled")},
                                   {PrimaryRole, QByteArrayLiteral("isPrimary")}});
     return roles;
 }
 
 void ScreenPoolModel::load()
 {
     beginResetModel();
     m_screens.clear();
     qDeleteAll(m_containments);
     m_containments.clear();
 
     QSet<int> unknownScreenIds;
     for (auto *cont : m_corona->containments()) {
         connect(cont, &Plasma::Containment::destroyedChanged, this, &ScreenPoolModel::load, Qt::UniqueConnection);
         if (!cont->destroyed()) {
             unknownScreenIds.insert(cont->lastScreen());
         }
     }
     int knownId = 0;
     for (QScreen *screen : m_corona->screenPool()->screenOrder()) {
         Data d;
         unknownScreenIds.remove(knownId);
         d.id = knownId;
         if (screen->name().contains(QStringLiteral("eDP"))) {
             d.name = i18n("Internal Screen on %1", screen->name());
         } else if (screen->model().contains(screen->name())) {
             d.name = screen->model();
         } else {
             d.name = i18nc("Screen manufacturer and model on connector", "%1 %2 on %3", screen->manufacturer(), screen->model(), screen->name());
         }
         d.primary = knownId == 0;
         d.enabled = true;
 
         auto *conts = new ShellContainmentModel(m_corona, knownId, this);
         conts->load();
 
         // Exclude screens which don't have any containemnt assigned
         if (conts->rowCount() > 0) {
             m_containments.push_back(conts);
             m_screens.push_back(d);
         } else {
             delete conts;
         }
         ++knownId;
     }
 
     QList sortedIds = unknownScreenIds.values();
     std::sort(sortedIds.begin(), sortedIds.end());
     int i = 1;
     for (int id : sortedIds) {
         Data d;
         d.id = id;
         d.name = i18n("Disconnected Screen %1", id + 1);
         d.primary = id == 0;
         d.enabled = false;
 
         auto *conts = new ShellContainmentModel(m_corona, id, this);
         conts->load();
         m_containments.push_back(conts);
         m_screens.push_back(d);
         i++;
     }
     endResetModel();
 }
 
 void ScreenPoolModel::remove(int screenId)
 {
     // Don't allow to remove currently used containemnts
     if (m_corona->screenPool()->screenForId(screenId)) {
         return;
     }
 
     // remove containments of *all* activities
     auto conts = m_corona->containmentsForScreen(screenId);
     for (auto *cont : std::as_const(conts)) {
         // Don't call destroy directly, so we can have the undo action notification
         auto *destroyAction = cont->actions()->action("remove");
         if (destroyAction) {
             destroyAction->trigger();
         }
     }
 }
 
 // ---
 
 ShellContainmentModel::ShellContainmentModel(ShellCorona *corona, int screenId, ScreenPoolModel *parent)
     : QAbstractListModel(parent)
     , m_screenId(screenId)
     , m_corona(corona)
     , m_screenPoolModel(parent)
     , m_activityConsumer(new KActivities::Consumer(this))
 {
     m_reloadTimer = new QTimer(this);
     m_reloadTimer->setSingleShot(true);
     m_reloadTimer->setInterval(200ms);
 
     connect(m_reloadTimer, &QTimer::timeout, this, &ShellContainmentModel::load);
 
     connect(m_corona, &ShellCorona::startupCompleted, this, &ShellContainmentModel::load);
 
     connect(m_corona, &Plasma::Corona::containmentAdded, m_reloadTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
     connect(m_corona, &Plasma::Corona::screenOwnerChanged, m_reloadTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
 
     connect(m_corona, &ShellCorona::containmentPreviewReady, this, [this](Plasma::Containment *containment, const QString &path) {
         int i = 0;
         for (auto &d : m_containments) {
             if (d.containment == containment) {
                 d.image = path;
                 emit dataChanged(index(i, 0), index(i, 0));
                 break;
             }
             ++i;
         }
     });
 }
 
 ShellContainmentModel::~ShellContainmentModel() = default;
 
 QVariant ShellContainmentModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.column() != 0 || index.row() < 0 || index.row() >= int(m_containments.size())) {
         return QVariant();
     }
     const Data &d = m_containments.at(index.row());
     switch (role) {
     case Qt::DisplayRole:
         return d.name;
     case ContainmentIdRole:
         return d.id;
     case NameRole:
         return d.name;
     case ScreenRole:
         return d.screen;
     case EdgeRole:
         return ShellContainmentModel::plasmaLocationToString(d.edge);
     case EdgePositionRole:
         return qMax(0, m_edgeCount.value(d.screen).value(d.edge).indexOf(d.id));
     case PanelCountAtRightRole:
         return qMax(0, m_edgeCount.value(d.screen).value(Plasma::Types::RightEdge).count());
     case PanelCountAtTopRole:
         return qMax(0, m_edgeCount.value(d.screen).value(Plasma::Types::TopEdge).count());
     case PanelCountAtLeftRole:
         return qMax(0, m_edgeCount.value(d.screen).value(Plasma::Types::LeftEdge).count());
     case PanelCountAtBottomRole:
         return qMax(0, m_edgeCount.value(d.screen).value(Plasma::Types::BottomEdge).count());
     case ActivityRole: {
         const auto *activityInfo = m_activitiesInfos.value(d.activity);
         if (activityInfo) {
             return activityInfo->name();
         }
         break;
     }
     case IsActiveRole:
         return d.isActive;
     case ImageSourceRole:
         return d.image;
     case DestroyedRole:
         return d.containment->destroyed();
     }
     return QVariant();
 }
 
 int ShellContainmentModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
     return m_containments.size();
 }
 
 QHash<int, QByteArray> ShellContainmentModel::roleNames() const
 {
     QHash<int, QByteArray> roles({{ContainmentIdRole, QByteArrayLiteral("containmentId")},
                                   {NameRole, QByteArrayLiteral("name")},
                                   {ScreenRole, QByteArrayLiteral("screen")},
                                   {EdgeRole, QByteArrayLiteral("edge")},
                                   {EdgePositionRole, QByteArrayLiteral("edgePosition")},
                                   {PanelCountAtRightRole, QByteArrayLiteral("panelCountAtRight")},
                                   {PanelCountAtTopRole, QByteArrayLiteral("panelCountAtTop")},
                                   {PanelCountAtLeftRole, QByteArrayLiteral("panelCountAtLeft")},
                                   {PanelCountAtBottomRole, QByteArrayLiteral("panelCountAtBottom")},
                                   {ActivityRole, QByteArrayLiteral("activity")},
                                   {IsActiveRole, QByteArrayLiteral("active")},
                                   {ImageSourceRole, QByteArrayLiteral("imageSource")},
                                   {DestroyedRole, QByteArrayLiteral("isDestroyed")}});
     return roles;
 }
 
 ScreenPoolModel *ShellContainmentModel::screenPoolModel() const
 {
     return m_screenPoolModel;
 }
 
 void ShellContainmentModel::remove(int contId)
 {
     if (contId < 0) {
         return;
     }
 
     auto *cont = containmentById(contId);
     if (cont) {
         disconnect(cont, nullptr, this, nullptr);
         // Don't call destroy directly, so we can have the undo action notification
         auto *destroyAction = cont->actions()->action("remove");
         if (destroyAction) {
             destroyAction->trigger();
         }
     }
     load();
 }
 
 void ShellContainmentModel::moveContainementToScreen(unsigned int contId, int newScreen)
 {
     if (contId == 0 || newScreen < 0) {
         return;
     }
 
     auto containmentIt = std::find_if(m_containments.begin(), m_containments.end(), [contId](Data &d) {
         return d.id == contId;
     });
     if (containmentIt == m_containments.end()) {
         return;
     }
     if (containmentIt->screen == newScreen) {
         return;
     }
 
     auto *cont = containmentById(contId);
     if (cont == nullptr) {
         return;
     }
 
     // If it's a panel, only move that one
     if (cont->containmentType() == Plasma::Types::PanelContainment || cont->containmentType() == Plasma::Types::CustomPanelContainment) {
         m_corona->setScreenForContainment(cont, newScreen);
     } else {
         // If it's a desktop, for now move all desktops for all activities
         const int oldScreen = cont->screen() >= 0 ? cont->screen() : cont->lastScreen();
         m_corona->swapDesktopScreens(oldScreen, newScreen);
     }
 }
 
 bool ShellContainmentModel::findContainment(unsigned int containmentId) const
 {
     return m_containments.cend() != std::find_if(m_containments.cbegin(), m_containments.cend(), [containmentId](const Data &d) {
                return d.id == containmentId;
            });
 }
 
 void ShellContainmentModel::load()
 {
     beginResetModel();
 
     for (auto &d : m_containments) {
         disconnect(d.containment, nullptr, this, nullptr);
     }
     m_containments.clear();
     m_edgeCount.clear();
 
     for (const auto *cont : m_corona->containments()) {
         // Skip the systray
         if (qobject_cast<Plasma::Applet *>(cont->parent())) {
             continue;
         }
         // Only allow current activity for now (panels always go in)
         if (cont->containmentType() != Plasma::Types::PanelContainment && cont->containmentType() != Plasma::Types::CustomPanelContainment
             && cont->activity() != m_activityConsumer->currentActivity()) {
             continue;
         }
         if (!m_edgeCount.contains(cont->lastScreen())) {
             m_edgeCount[cont->lastScreen()] = QHash<Plasma::Types::Location, QList<int>>();
             m_edgeCount[cont->lastScreen()][cont->location()] = QList<int>();
         }
         m_edgeCount[cont->lastScreen()][cont->location()].append(cont->id());
         m_corona->grabContainmentPreview(const_cast<Plasma::Containment *>(cont));
         Data d;
         d.id = cont->id();
         d.name = cont->title() + " (" + ShellContainmentModel::containmentTypeToString(cont->containmentType()) + ")";
         d.screen = cont->lastScreen();
         d.edge = cont->location();
         d.activity = cont->activity();
         d.isActive = cont->screen() != -1;
         d.containment = cont;
         d.image = containmentPreview(const_cast<Plasma::Containment *>(cont));
 
         if (cont->lastScreen() == m_screenId || (cont->lastScreen() == -1 && cont->screen() == m_screenId)) {
             m_containments.push_back(d);
             connect(cont, &QObject::destroyed, this, &ShellContainmentModel::load);
             connect(cont, &Plasma::Containment::destroyedChanged, this, &ShellContainmentModel::load);
             connect(cont, &Plasma::Containment::locationChanged, this, &ShellContainmentModel::load);
         }
     }
     endResetModel();
 }
 
 void ShellContainmentModel::loadActivitiesInfos()
 {
     beginResetModel();
     for (const auto &cont : m_containments) {
         const auto activitId = cont.activity;
         if (activitId.isEmpty()) {
             continue;
         }
         auto *activityInfo = new KActivities::Info(cont.activity, this);
         if (activityInfo) {
             if (!m_activitiesInfos.value(cont.activity)) {
                 m_activitiesInfos[cont.activity] = activityInfo;
             }
         }
     }
     endResetModel();
 }
 
 QString ShellContainmentModel::plasmaLocationToString(Plasma::Types::Location location)
 {
     switch (location) {
     case Plasma::Types::Floating:
         return QStringLiteral("floating");
     case Plasma::Types::Desktop:
         return QStringLiteral("desktop");
     case Plasma::Types::FullScreen:
         return QStringLiteral("Full Screen");
     case Plasma::Types::TopEdge:
         return QStringLiteral("top");
     case Plasma::Types::BottomEdge:
         return QStringLiteral("bottom");
     case Plasma::Types::LeftEdge:
         return QStringLiteral("left");
     case Plasma::Types::RightEdge:
         return QStringLiteral("right");
     default:
         return QString("unknown");
     }
 }
 
 QString ShellContainmentModel::containmentTypeToString(Plasma::Types::ContainmentType containmentType)
 {
     switch (containmentType) {
     case Plasma::Types::DesktopContainment: /**< A desktop containment */
         return QStringLiteral("Desktop");
     case Plasma::Types::PanelContainment: /**< A desktop panel */
         return QStringLiteral("Panel");
     case Plasma::Types::CustomContainment: /**< A containment that is neither a desktop nor a panel
                             but something application specific */
         return QStringLiteral("Custom");
     case Plasma::Types::CustomPanelContainment: /**< A customized desktop panel */
         return QStringLiteral("Custom Desktop");
     case Plasma::Types::CustomEmbeddedContainment: /**< A customized containment embedded in another applet */
         return QStringLiteral("Embedded");
     default:
         return QStringLiteral("Unknown");
     }
 }
 
 Plasma::Containment *ShellContainmentModel::containmentById(unsigned int id)
 {
     for (auto *cont : m_corona->containments()) {
         if (cont->id() == id) {
             return cont;
         }
     }
     return nullptr;
 }
 
 QString ShellContainmentModel::containmentPreview(Plasma::Containment *containment)
 {
     QString savedThumbnail = m_corona->containmentPreviewPath(containment);
 
     if (!savedThumbnail.isEmpty()) {
         return savedThumbnail;
     }
 
     m_corona->grabContainmentPreview(containment);
 
     // If not found, try to understand the configured wallpaper for the containment, assuming is using the Image plugin
     KSharedConfig::Ptr conf = KSharedConfig::openConfig(QLatin1String("plasma-") + m_corona->shell() + QLatin1String("-appletsrc"), KConfig::SimpleConfig);
     KConfigGroup containmentsGroup(conf, "Containments");
     KConfigGroup config = containmentsGroup.group(QString::number(containment->id()));
     auto wallpaperPlugin = config.readEntry("wallpaperplugin");
     auto wallpaperConfig = config.group("Wallpaper").group(wallpaperPlugin).group("General");
 
     if (wallpaperConfig.hasKey("Image")) {
         // Trying for the wallpaper
         auto wallpaper = wallpaperConfig.readEntry("Image", QString());
         if (!wallpaper.isEmpty()) {
             return wallpaper;
         }
     }
     if (wallpaperConfig.hasKey("Color")) {
         auto backgroundColor = wallpaperConfig.readEntry("Color", QColor(0, 0, 0));
         return backgroundColor.name();
     }
 
     return QString();
 }
 
 // ---
 
 ShellContainmentConfig::ShellContainmentConfig(ShellCorona *corona, QWindow *parent)
     : QQmlApplicationEngine(parent)
     , m_corona(corona)
     , m_model(nullptr)
 {
 }
 
 ShellContainmentConfig::~ShellContainmentConfig() = default;
 
 void ShellContainmentConfig::init()
 {
     m_model = new ScreenPoolModel(m_corona, this);
     m_model->load();
 
     auto *localizedContext = new KLocalizedContext(this);
     localizedContext->setTranslationDomain(QStringLiteral("plasma_shell_") + m_corona->shell());
 
     rootContext()->setContextObject(localizedContext);
     rootContext()->setContextProperty(QStringLiteral("ShellContainmentModel"), m_model);
     load(m_corona->kPackage().fileUrl("containmentmanagementui"));
 
     if (!rootObjects().isEmpty()) {
         auto *obj = qobject_cast<QWindow *>(rootObjects().first());
         connect(obj, &QWindow::visibleChanged, this, [this, obj]() {
             deleteLater();
         });
     }
 }