kwin/src/activities.cpp
2022-07-21 15:24:51 +02:00

204 lines
6.4 KiB
C++

/*
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 "window.h"
#include "workspace.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);
}
KActivities::Consumer::ServiceStatus Activities::serviceStatus() const
{
return m_controller->serviceStatus();
}
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()->allClientList();
for (auto *const window : windows) {
if (window->isDesktop()) {
continue;
}
window->setOnActivity(activity, false);
}
// toss out any session data for it
KConfigGroup cg(KSharedConfig::openConfig(), QByteArray("SubSession: ").append(activity.toUtf8()).constData());
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, "reallyStop", Qt::QueuedConnection, Q_ARG(QString, id));
// 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->allClientList();
for (auto *const window : windows) {
if (window->isDesktop()) {
continue;
}
const QByteArray sessionId = window->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 : qAsConst(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