File indexing completed on 2024-04-28 05:30:12

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "activities.h"
 // KWin
 #include "workspace.h"
 #include "x11window.h"
 // KDE
 #include <KConfigGroup>
 // Qt
 #include <QDBusInterface>
 #include <QDBusPendingCall>
 #include <QFutureWatcher>
 #include <QtConcurrentRun>
 
 namespace KWin
 {
 
 Activities::Activities()
     : m_controller(new KActivities::Controller(this))
 {
     connect(m_controller, &KActivities::Controller::activityRemoved, this, &Activities::slotRemoved);
     connect(m_controller, &KActivities::Controller::activityRemoved, this, &Activities::removed);
     connect(m_controller, &KActivities::Controller::activityAdded, this, &Activities::added);
     connect(m_controller, &KActivities::Controller::currentActivityChanged, this, &Activities::slotCurrentChanged);
     connect(m_controller, &KActivities::Controller::serviceStatusChanged, this, &Activities::slotServiceStatusChanged);
 }
 
 KActivities::Consumer::ServiceStatus Activities::serviceStatus() const
 {
     return m_controller->serviceStatus();
 }
 
 void Activities::slotServiceStatusChanged()
 {
     if (m_controller->serviceStatus() != KActivities::Consumer::Running) {
         return;
     }
     const auto windows = Workspace::self()->windows();
     for (auto *const window : windows) {
         if (!window->isClient()) {
             continue;
         }
         if (window->isDesktop()) {
             continue;
         }
         window->checkActivities();
     }
 }
 
 void Activities::setCurrent(const QString &activity)
 {
     m_controller->setCurrentActivity(activity);
 }
 
 void Activities::slotCurrentChanged(const QString &newActivity)
 {
     if (m_current == newActivity) {
         return;
     }
     m_previous = m_current;
     m_current = newActivity;
     Q_EMIT currentChanged(newActivity);
 }
 
 void Activities::slotRemoved(const QString &activity)
 {
     const auto windows = Workspace::self()->windows();
     for (auto *const window : windows) {
         if (!window->isClient()) {
             continue;
         }
         if (window->isDesktop()) {
             continue;
         }
         window->setOnActivity(activity, false);
     }
     // toss out any session data for it
     KConfigGroup cg(KSharedConfig::openConfig(), QLatin1String("SubSession: ") + activity);
     cg.deleteGroup();
 }
 
 void Activities::toggleWindowOnActivity(Window *window, const QString &activity, bool dont_activate)
 {
     // int old_desktop = window->desktop();
     bool was_on_activity = window->isOnActivity(activity);
     bool was_on_all = window->isOnAllActivities();
     // note: all activities === no activities
     bool enable = was_on_all || !was_on_activity;
     window->setOnActivity(activity, enable);
     if (window->isOnActivity(activity) == was_on_activity && window->isOnAllActivities() == was_on_all) { // No change
         return;
     }
 
     Workspace *ws = Workspace::self();
     if (window->isOnCurrentActivity()) {
         if (window->wantsTabFocus() && options->focusPolicyIsReasonable() && !was_on_activity && // for stickyness changes
                                                                                                  // FIXME not sure if the line above refers to the correct activity
             !dont_activate) {
             ws->requestFocus(window);
         } else {
             ws->restackWindowUnderActive(window);
         }
     } else {
         ws->raiseWindow(window);
     }
 
     // notifyWindowDesktopChanged( c, old_desktop );
 
     const auto transients_stacking_order = ws->ensureStackingOrder(window->transients());
     for (auto *const window : transients_stacking_order) {
         if (!window) {
             continue;
         }
         toggleWindowOnActivity(window, activity, dont_activate);
     }
     ws->updateClientArea();
 }
 
 bool Activities::start(const QString &id)
 {
     Workspace *ws = Workspace::self();
     if (ws->sessionManager()->state() == SessionState::Saving) {
         return false; // ksmserver doesn't queue requests (yet)
     }
 
     if (!all().contains(id)) {
         return false; // bogus id
     }
 
     ws->sessionManager()->loadSubSessionInfo(id);
 
     QDBusInterface ksmserver("org.kde.ksmserver", "/KSMServer", "org.kde.KSMServerInterface");
     if (ksmserver.isValid()) {
         ksmserver.asyncCall("restoreSubSession", id);
     } else {
         qCDebug(KWIN_CORE) << "couldn't get ksmserver interface";
         return false;
     }
     return true;
 }
 
 bool Activities::stop(const QString &id)
 {
     if (Workspace::self()->sessionManager()->state() == SessionState::Saving) {
         return false; // ksmserver doesn't queue requests (yet)
         // FIXME what about session *loading*?
     }
 
     // ugly hack to avoid dbus deadlocks
     QMetaObject::invokeMethod(
         this, [this, id] {
             reallyStop(id);
         },
         Qt::QueuedConnection);
     // then lie and assume it worked.
     return true;
 }
 
 void Activities::reallyStop(const QString &id)
 {
     Workspace *ws = Workspace::self();
     if (ws->sessionManager()->state() == SessionState::Saving) {
         return; // ksmserver doesn't queue requests (yet)
     }
 
     qCDebug(KWIN_CORE) << id;
 
     QSet<QByteArray> saveSessionIds;
     QSet<QByteArray> dontCloseSessionIds;
     const auto windows = ws->windows();
     for (auto *const window : windows) {
         auto x11Window = qobject_cast<X11Window *>(window);
         if (!x11Window || window->isUnmanaged()) {
             continue;
         }
         if (window->isDesktop()) {
             continue;
         }
         const QByteArray sessionId = x11Window->sessionId();
         if (sessionId.isEmpty()) {
             continue; // TODO support old wm_command apps too?
         }
 
         // qDebug() << sessionId;
 
         // if it's on the activity that's closing, it needs saving
         // but if a process is on some other open activity, I don't wanna close it yet
         // this is, of course, complicated by a process having many windows.
         if (window->isOnAllActivities()) {
             dontCloseSessionIds << sessionId;
             continue;
         }
 
         const QStringList activities = window->activities();
         for (const QString &activityId : activities) {
             if (activityId == id) {
                 saveSessionIds << sessionId;
             } else if (running().contains(activityId)) {
                 dontCloseSessionIds << sessionId;
             }
         }
     }
 
     ws->sessionManager()->storeSubSession(id, saveSessionIds);
 
     QStringList saveAndClose;
     QStringList saveOnly;
     for (const QByteArray &sessionId : std::as_const(saveSessionIds)) {
         if (dontCloseSessionIds.contains(sessionId)) {
             saveOnly << sessionId;
         } else {
             saveAndClose << sessionId;
         }
     }
 
     qCDebug(KWIN_CORE) << "saveActivity" << id << saveAndClose << saveOnly;
 
     // pass off to ksmserver
     QDBusInterface ksmserver("org.kde.ksmserver", "/KSMServer", "org.kde.KSMServerInterface");
     if (ksmserver.isValid()) {
         ksmserver.asyncCall("saveSubSession", id, saveAndClose, saveOnly);
     } else {
         qCDebug(KWIN_CORE) << "couldn't get ksmserver interface";
     }
 }
 
 } // namespace
 
 #include "moc_activities.cpp"