diff --git a/activities.cpp b/activities.cpp
index 25eb1c146..42c5db801 100644
--- a/activities.cpp
+++ b/activities.cpp
@@ -1,218 +1,218 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "activities.h"
 // KWin
 #include "client.h"
 #include "workspace.h"
 // KDE
 #include <KConfigGroup>
 #include <kactivities/controller.h>
 // Qt
 #include <QtConcurrentRun>
 #include <QDBusInterface>
 #include <QDBusPendingCall>
 #include <QFutureWatcher>
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(Activities)
 
 Activities::Activities(QObject *parent)
     : QObject(parent)
     , 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);
 }
 
 Activities::~Activities()
 {
     s_self = NULL;
 }
 
 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;
     emit currentChanged(newActivity);
 }
 
 void Activities::slotRemoved(const QString &activity)
 {
     foreach (Client * client, Workspace::self()->clientList()) {
         client->setOnActivity(activity, false);
     }
     //toss out any session data for it
     KConfigGroup cg(KSharedConfig::openConfig(), QByteArray("SubSession: ").append(activity.toUtf8()).constData());
     cg.deleteGroup();
 }
 
 void Activities::toggleClientOnActivity(Client* c, const QString &activity, bool dont_activate)
 {
     //int old_desktop = c->desktop();
     bool was_on_activity = c->isOnActivity(activity);
     bool was_on_all = c->isOnAllActivities();
     //note: all activities === no activities
     bool enable = was_on_all || !was_on_activity;
     c->setOnActivity(activity, enable);
     if (c->isOnActivity(activity) == was_on_activity && c->isOnAllActivities() == was_on_all)   // No change
         return;
 
     Workspace *ws = Workspace::self();
     if (c->isOnCurrentActivity()) {
         if (c->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(c);
         else
             ws->restackClientUnderActive(c);
     } else
         ws->raiseClient(c);
 
     //notifyWindowDesktopChanged( c, old_desktop );
 
     auto transients_stacking_order = ws->ensureStackingOrder(c->transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it) {
         Client *c = dynamic_cast<Client *>(*it);
         if (!c) {
             continue;
         }
         toggleClientOnActivity(c, activity, dont_activate);
     }
     ws->updateClientArea();
 }
 
 bool Activities::start(const QString &id)
 {
     Workspace *ws = Workspace::self();
     if (ws->sessionSaving()) {
         return false; //ksmserver doesn't queue requests (yet)
     }
 
     if (!all().contains(id)) {
         return false; //bogus id
     }
 
     ws->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()->sessionSaving()) {
         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->sessionSaving())
         return; //ksmserver doesn't queue requests (yet)
 
     qCDebug(KWIN_CORE) << id;
 
     QSet<QByteArray> saveSessionIds;
     QSet<QByteArray> dontCloseSessionIds;
     const ClientList &clients = ws->clientList();
     for (ClientList::const_iterator it = clients.constBegin(); it != clients.constEnd(); ++it) {
         const Client* c = (*it);
         const QByteArray sessionId = c->sessionId();
         if (sessionId.isEmpty()) {
-            continue;
+            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 (c->isOnAllActivities()) {
             dontCloseSessionIds << sessionId;
             continue;
         }
 
         const QStringList activities = c->activities();
         foreach (const QString & activityId, activities) {
             if (activityId == id) {
                 saveSessionIds << sessionId;
             } else if (running().contains(activityId)) {
                 dontCloseSessionIds << sessionId;
             }
         }
     }
 
     ws->storeSubSession(id, saveSessionIds);
 
     QStringList saveAndClose;
     QStringList saveOnly;
     foreach (const QByteArray & sessionId, 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
diff --git a/sm.cpp b/sm.cpp
index 08810a472..ca1edeae5 100644
--- a/sm.cpp
+++ b/sm.cpp
@@ -1,519 +1,532 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "sm.h"
 
 #include <unistd.h>
 #include <stdlib.h>
 #include <pwd.h>
 #include <fixx11h.h>
 #include <kconfig.h>
 
 #include "workspace.h"
 #include "client.h"
 #include <QDebug>
 #include <QFile>
 #include <QSocketNotifier>
 #include <QSessionManager>
 
 namespace KWin
 {
 
 static bool gs_sessionManagerIsKSMServer = false;
 static KConfig *sessionConfig(QString id, QString key)
 {
     static KConfig *config = nullptr;
     static QString lastId;
     static QString lastKey;
     static QString pattern = QString(QLatin1String("session/%1_%2_%3")).arg(qApp->applicationName());
     if (id != lastId || key != lastKey) {
         delete config;
         config = nullptr;
     }
     lastId = id;
     lastKey = key;
     if (!config) {
         config = new KConfig(pattern.arg(id).arg(key), KConfig::SimpleConfig);
     }
     return config;
 }
 
 void Workspace::saveState(QSessionManager &sm)
 {
     // If the session manager is ksmserver, save stacking
     // order, active window, active desktop etc. in phase 1,
     // as ksmserver assures no interaction will be done
     // before the WM finishes phase 1. Saving in phase 2 is
     // too late, as possible user interaction may change some things.
     // Phase2 is still needed though (ICCCM 5.2)
     KConfig *config = sessionConfig(sm.sessionId(), sm.sessionKey());
     if (!sm.isPhase2()) {
         KConfigGroup cg(config, "Session");
         cg.writeEntry("AllowsInteraction", sm.allowsInteraction());
         sessionSaveStarted();
         if (gs_sessionManagerIsKSMServer)   // save stacking order etc. before "save file?" etc. dialogs change it
             storeSession(config, SMSavePhase0);
         config->markAsClean(); // don't write Phase #1 data to disk
         sm.release(); // Qt doesn't automatically release in this case (bug?)
         sm.requestPhase2();
         return;
     }
     storeSession(config, gs_sessionManagerIsKSMServer ? SMSavePhase2 : SMSavePhase2Full);
     config->sync();
 
     // inform the smserver on how to clean-up after us
     const QString localFilePath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + QLatin1Char('/') + config->name();
     if (QFile::exists(localFilePath)) { // expectable for the sync
         sm.setDiscardCommand(QStringList() << QStringLiteral("rm") << localFilePath);
     }
 }
 
 // I bet this is broken, just like everywhere else in KDE
 void Workspace::commitData(QSessionManager &sm)
 {
     if (!sm.isPhase2())
         sessionSaveStarted();
 }
 
 // Workspace
 
 /*!
   Stores the current session in the config file
 
   \sa loadSessionInfo()
  */
 void Workspace::storeSession(KConfig* config, SMSavePhase phase)
 {
     KConfigGroup cg(config, "Session");
     int count =  0;
     int active_client = -1;
 
     for (ClientList::Iterator it = clients.begin(); it != clients.end(); ++it) {
         Client* c = (*it);
         QByteArray sessionId = c->sessionId();
+        QByteArray wmCommand = c->wmCommand();
         if (sessionId.isEmpty())
-            continue;
+            // remember also applications that are not XSMP capable
+            // and use the obsolete WM_COMMAND / WM_SAVE_YOURSELF
+            if (wmCommand.isEmpty())
+                continue;
         count++;
         if (c->isActive())
             active_client = count;
         if (phase == SMSavePhase2 || phase == SMSavePhase2Full)
             storeClient(cg, count, c);
     }
     if (phase == SMSavePhase0) {
         // it would be much simpler to save these values to the config file,
         // but both Qt and KDE treat phase1 and phase2 separately,
         // which results in different sessionkey and different config file :(
         session_active_client = active_client;
         session_desktop = VirtualDesktopManager::self()->current();
     } else if (phase == SMSavePhase2) {
         cg.writeEntry("count", count);
         cg.writeEntry("active", session_active_client);
         cg.writeEntry("desktop", session_desktop);
     } else { // SMSavePhase2Full
         cg.writeEntry("count", count);
         cg.writeEntry("active", session_active_client);
         cg.writeEntry("desktop", VirtualDesktopManager::self()->current());
     }
 }
 
 void Workspace::storeClient(KConfigGroup &cg, int num, Client *c)
 {
     c->setSessionInteract(false); //make sure we get the real values
     QString n = QString::number(num);
     cg.writeEntry(QLatin1String("sessionId") + n, c->sessionId().constData());
     cg.writeEntry(QLatin1String("windowRole") + n, c->windowRole().constData());
+    cg.writeEntry(QLatin1String("wmCommand") + n, c->wmCommand().constData());
     cg.writeEntry(QLatin1String("resourceName") + n, c->resourceName().constData());
     cg.writeEntry(QLatin1String("resourceClass") + n, c->resourceClass().constData());
     cg.writeEntry(QLatin1String("geometry") + n, QRect(c->calculateGravitation(true), c->clientSize()));   // FRAME
     cg.writeEntry(QLatin1String("restore") + n, c->geometryRestore());
     cg.writeEntry(QLatin1String("fsrestore") + n, c->geometryFSRestore());
     cg.writeEntry(QLatin1String("maximize") + n, (int) c->maximizeMode());
     cg.writeEntry(QLatin1String("fullscreen") + n, (int) c->fullScreenMode());
     cg.writeEntry(QLatin1String("desktop") + n, c->desktop());
     // the config entry is called "iconified" for back. comp. reasons
     // (kconf_update script for updating session files would be too complicated)
     cg.writeEntry(QLatin1String("iconified") + n, c->isMinimized());
     cg.writeEntry(QLatin1String("opacity") + n, c->opacity());
     // the config entry is called "sticky" for back. comp. reasons
     cg.writeEntry(QLatin1String("sticky") + n, c->isOnAllDesktops());
     cg.writeEntry(QLatin1String("shaded") + n, c->isShade());
     // the config entry is called "staysOnTop" for back. comp. reasons
     cg.writeEntry(QLatin1String("staysOnTop") + n, c->keepAbove());
     cg.writeEntry(QLatin1String("keepBelow") + n, c->keepBelow());
     cg.writeEntry(QLatin1String("skipTaskbar") + n, c->originalSkipTaskbar());
     cg.writeEntry(QLatin1String("skipPager") + n, c->skipPager());
     cg.writeEntry(QLatin1String("skipSwitcher") + n, c->skipSwitcher());
     // not really just set by user, but name kept for back. comp. reasons
     cg.writeEntry(QLatin1String("userNoBorder") + n, c->noBorder());
     cg.writeEntry(QLatin1String("windowType") + n, windowTypeToTxt(c->windowType()));
     cg.writeEntry(QLatin1String("shortcut") + n, c->shortcut().toString());
     cg.writeEntry(QLatin1String("stackingOrder") + n, unconstrained_stacking_order.indexOf(c));
     // KConfig doesn't support long so we need to live with less precision on 64-bit systems
     cg.writeEntry(QLatin1String("tabGroup") + n, static_cast<int>(reinterpret_cast<long>(c->tabGroup())));
     cg.writeEntry(QLatin1String("activities") + n, c->activities());
 }
 
 void Workspace::storeSubSession(const QString &name, QSet<QByteArray> sessionIds)
 {
     //TODO clear it first
     KConfigGroup cg(KSharedConfig::openConfig(), QLatin1String("SubSession: ") + name);
     int count =  0;
     int active_client = -1;
     for (ClientList::Iterator it = clients.begin(); it != clients.end(); ++it) {
         Client* c = (*it);
         QByteArray sessionId = c->sessionId();
+        QByteArray wmCommand = c->wmCommand();
         if (sessionId.isEmpty())
-            continue;
+            // remember also applications that are not XSMP capable
+            // and use the obsolete WM_COMMAND / WM_SAVE_YOURSELF
+            if (wmCommand.isEmpty())
+                continue;
         if (!sessionIds.contains(sessionId))
             continue;
 
         qCDebug(KWIN_CORE) << "storing" << sessionId;
         count++;
         if (c->isActive())
             active_client = count;
         storeClient(cg, count, c);
     }
     cg.writeEntry("count", count);
     cg.writeEntry("active", active_client);
     //cg.writeEntry( "desktop", currentDesktop());
 }
 
 /*!
   Loads the session information from the config file.
 
   \sa storeSession()
  */
 void Workspace::loadSessionInfo(const QString &key)
 {
     // NOTICE: qApp->sessionKey() is outdated when this gets invoked
     // the key parameter is cached from the application constructor.
     session.clear();
     KConfigGroup cg(sessionConfig(qApp->sessionId(), key), "Session");
     addSessionInfo(cg);
 }
 
 void Workspace::addSessionInfo(KConfigGroup &cg)
 {
     m_initialDesktop = cg.readEntry("desktop", 1);
     int count =  cg.readEntry("count", 0);
     int active_client = cg.readEntry("active", 0);
     for (int i = 1; i <= count; i++) {
         QString n = QString::number(i);
         SessionInfo* info = new SessionInfo;
         session.append(info);
         info->sessionId = cg.readEntry(QLatin1String("sessionId") + n, QString()).toLatin1();
         info->windowRole = cg.readEntry(QLatin1String("windowRole") + n, QString()).toLatin1();
+        info->wmCommand = cg.readEntry(QLatin1String("wmCommand") + n, QString()).toLatin1();
         info->resourceName = cg.readEntry(QLatin1String("resourceName") + n, QString()).toLatin1();
         info->resourceClass = cg.readEntry(QLatin1String("resourceClass") + n, QString()).toLower().toLatin1();
         info->geometry = cg.readEntry(QLatin1String("geometry") + n, QRect());
         info->restore = cg.readEntry(QLatin1String("restore") + n, QRect());
         info->fsrestore = cg.readEntry(QLatin1String("fsrestore") + n, QRect());
         info->maximized = cg.readEntry(QLatin1String("maximize") + n, 0);
         info->fullscreen = cg.readEntry(QLatin1String("fullscreen") + n, 0);
         info->desktop = cg.readEntry(QLatin1String("desktop") + n, 0);
         info->minimized = cg.readEntry(QLatin1String("iconified") + n, false);
         info->opacity = cg.readEntry(QLatin1String("opacity") + n, 1.0);
         info->onAllDesktops = cg.readEntry(QLatin1String("sticky") + n, false);
         info->shaded = cg.readEntry(QLatin1String("shaded") + n, false);
         info->keepAbove = cg.readEntry(QLatin1String("staysOnTop") + n, false);
         info->keepBelow = cg.readEntry(QLatin1String("keepBelow") + n, false);
         info->skipTaskbar = cg.readEntry(QLatin1String("skipTaskbar") + n, false);
         info->skipPager = cg.readEntry(QLatin1String("skipPager") + n, false);
         info->skipSwitcher = cg.readEntry(QLatin1String("skipSwitcher") + n, false);
         info->noBorder = cg.readEntry(QLatin1String("userNoBorder") + n, false);
         info->windowType = txtToWindowType(cg.readEntry(QLatin1String("windowType") + n, QString()).toLatin1().constData());
         info->shortcut = cg.readEntry(QLatin1String("shortcut") + n, QString());
         info->active = (active_client == i);
         info->stackingOrder = cg.readEntry(QLatin1String("stackingOrder") + n, -1);
         info->tabGroup = cg.readEntry(QLatin1String("tabGroup") + n, 0);
         info->tabGroupClient = NULL;
         info->activities = cg.readEntry(QLatin1String("activities") + n, QStringList());
     }
 }
 
 void Workspace::loadSubSessionInfo(const QString &name)
 {
     KConfigGroup cg(KSharedConfig::openConfig(), QLatin1String("SubSession: ") + name);
     addSessionInfo(cg);
 }
 
 /*!
   Returns a SessionInfo for client \a c. The returned session
   info is removed from the storage. It's up to the caller to delete it.
 
   This function is called when a new window is mapped and must be managed.
   We try to find a matching entry in the session.
 
   May return 0 if there's no session info for the client.
  */
 SessionInfo* Workspace::takeSessionInfo(Client* c)
 {
     SessionInfo *realInfo = 0;
     QByteArray sessionId = c->sessionId();
     QByteArray windowRole = c->windowRole();
+    QByteArray wmCommand = c->wmCommand();
     QByteArray resourceName = c->resourceName();
     QByteArray resourceClass = c->resourceClass();
 
     // First search ``session''
     if (! sessionId.isEmpty()) {
         // look for a real session managed client (algorithm suggested by ICCCM)
         foreach (SessionInfo * info, session) {
             if (realInfo)
                 break;
             if (info->sessionId == sessionId && sessionInfoWindowTypeMatch(c, info)) {
                 if (! windowRole.isEmpty()) {
                     if (info->windowRole == windowRole) {
                         realInfo = info;
                         session.removeAll(info);
                     }
                 } else {
                     if (info->windowRole.isEmpty()
                             && info->resourceName == resourceName
                             && info->resourceClass == resourceClass) {
                         realInfo = info;
                         session.removeAll(info);
                     }
                 }
             }
         }
     } else {
         // look for a sessioninfo with matching features.
         foreach (SessionInfo * info, session) {
             if (realInfo)
                 break;
             if (info->resourceName == resourceName
                     && info->resourceClass == resourceClass
                     && sessionInfoWindowTypeMatch(c, info)) {
-                realInfo = info;
-                session.removeAll(info);
+                if (wmCommand.isEmpty() || info->wmCommand == wmCommand) {
+                    realInfo = info;
+                    session.removeAll(info);
+                }
             }
         }
     }
 
     // Set tabGroupClient for other clients in the same group
     if (realInfo && realInfo->tabGroup) {
         foreach (SessionInfo * info, session) {
             if (!info->tabGroupClient && info->tabGroup == realInfo->tabGroup)
                 info->tabGroupClient = c;
         }
     }
 
     return realInfo;
 }
 
 bool Workspace::sessionInfoWindowTypeMatch(Client* c, SessionInfo* info)
 {
     if (info->windowType == -2) {
         // undefined (not really part of NET::WindowType)
         return !c->isSpecialWindow();
     }
     return info->windowType == c->windowType();
 }
 
 static const char* const window_type_names[] = {
     "Unknown", "Normal" , "Desktop", "Dock", "Toolbar", "Menu", "Dialog",
     "Override", "TopMenu", "Utility", "Splash"
 };
 // change also the two functions below when adding new entries
 
 const char* Workspace::windowTypeToTxt(NET::WindowType type)
 {
     if (type >= NET::Unknown && type <= NET::Splash)
         return window_type_names[ type + 1 ]; // +1 (unknown==-1)
     if (type == -2)   // undefined (not really part of NET::WindowType)
         return "Undefined";
     qFatal("Unknown Window Type");
     return NULL;
 }
 
 NET::WindowType Workspace::txtToWindowType(const char* txt)
 {
     for (int i = NET::Unknown;
             i <= NET::Splash;
             ++i)
         if (qstrcmp(txt, window_type_names[ i + 1 ]) == 0)     // +1
             return static_cast< NET::WindowType >(i);
     return static_cast< NET::WindowType >(-2);   // undefined
 }
 
 
 
 
 // KWin's focus stealing prevention causes problems with user interaction
 // during session save, as it prevents possible dialogs from getting focus.
 // Therefore it's temporarily disabled during session saving. Start of
 // session saving can be detected in SessionManager::saveState() above,
 // but Qt doesn't have API for saying when session saved finished (either
 // successfully, or was canceled). Therefore, create another connection
 // to session manager, that will provide this information.
 // Similarly the remember feature of window-specific settings should be disabled
 // during KDE shutdown when windows may move e.g. because of Kicker going away
 // (struts changing). When session saving starts, it can be cancelled, in which
 // case the shutdown_cancelled callback is invoked, or it's a checkpoint that
 // is immediatelly followed by save_complete, or finally it's a shutdown that
 // is immediatelly followed by die callback. So getting save_yourself with shutdown
 // set disables window-specific settings remembering, getting shutdown_cancelled
 // re-enables, otherwise KWin will go away after die.
 static void save_yourself(SmcConn conn_P, SmPointer ptr, int, Bool shutdown, int, Bool)
 {
     SessionSaveDoneHelper* session = reinterpret_cast< SessionSaveDoneHelper* >(ptr);
     if (conn_P != session->connection())
         return;
     if (shutdown)
         RuleBook::self()->setUpdatesDisabled(true);
     SmcSaveYourselfDone(conn_P, True);
 }
 
 static void die(SmcConn conn_P, SmPointer ptr)
 {
     SessionSaveDoneHelper* session = reinterpret_cast< SessionSaveDoneHelper* >(ptr);
     if (conn_P != session->connection())
         return;
     // session->saveDone(); we will quit anyway
     session->close();
 }
 
 static void save_complete(SmcConn conn_P, SmPointer ptr)
 {
     SessionSaveDoneHelper* session = reinterpret_cast< SessionSaveDoneHelper* >(ptr);
     if (conn_P != session->connection())
         return;
     session->saveDone();
 }
 
 static void shutdown_cancelled(SmcConn conn_P, SmPointer ptr)
 {
     SessionSaveDoneHelper* session = reinterpret_cast< SessionSaveDoneHelper* >(ptr);
     if (conn_P != session->connection())
         return;
     RuleBook::self()->setUpdatesDisabled(false);   // re-enable
     // no need to differentiate between successful finish and cancel
     session->saveDone();
 }
 
 void SessionSaveDoneHelper::saveDone()
 {
     if (Workspace::self())
         Workspace::self()->sessionSaveDone();
 }
 
 SessionSaveDoneHelper::SessionSaveDoneHelper()
 {
     SmcCallbacks calls;
     calls.save_yourself.callback = save_yourself;
     calls.save_yourself.client_data = reinterpret_cast< SmPointer >(this);
     calls.die.callback = die;
     calls.die.client_data = reinterpret_cast< SmPointer >(this);
     calls.save_complete.callback = save_complete;
     calls.save_complete.client_data = reinterpret_cast< SmPointer >(this);
     calls.shutdown_cancelled.callback = shutdown_cancelled;
     calls.shutdown_cancelled.client_data = reinterpret_cast< SmPointer >(this);
     char* id = NULL;
     char err[ 11 ];
     conn = SmcOpenConnection(NULL, 0, 1, 0,
                              SmcSaveYourselfProcMask | SmcDieProcMask | SmcSaveCompleteProcMask
                              | SmcShutdownCancelledProcMask, &calls, NULL, &id, 10, err);
     if (id != NULL)
         free(id);
     if (conn == NULL)
         return; // no SM
 
     // detect ksmserver
     // NOTICE: no idea whether the assumptions about it in Workspace::saveState()
     // still hold for KF5/Plasma 5
 #warning assuming special behavior in ksmserver to be still present in KF5
     char* vendor = SmcVendor(conn);
     gs_sessionManagerIsKSMServer = qstrcmp(vendor, "KDE") == 0;
     free(vendor);
 
     // set the required properties, mostly dummy values
     SmPropValue propvalue[ 5 ];
     SmProp props[ 5 ];
     propvalue[ 0 ].length = sizeof(unsigned char);
     unsigned char value0 = SmRestartNever; // so that this extra SM connection doesn't interfere
     propvalue[ 0 ].value = &value0;
     props[ 0 ].name = const_cast< char* >(SmRestartStyleHint);
     props[ 0 ].type = const_cast< char* >(SmCARD8);
     props[ 0 ].num_vals = 1;
     props[ 0 ].vals = &propvalue[ 0 ];
     struct passwd* entry = getpwuid(geteuid());
     propvalue[ 1 ].length = entry != NULL ? strlen(entry->pw_name) : 0;
     propvalue[ 1 ].value = (SmPointer)(entry != NULL ? entry->pw_name : "");
     props[ 1 ].name = const_cast< char* >(SmUserID);
     props[ 1 ].type = const_cast< char* >(SmARRAY8);
     props[ 1 ].num_vals = 1;
     props[ 1 ].vals = &propvalue[ 1 ];
     propvalue[ 2 ].length = 0;
     propvalue[ 2 ].value = (SmPointer)("");
     props[ 2 ].name = const_cast< char* >(SmRestartCommand);
     props[ 2 ].type = const_cast< char* >(SmLISTofARRAY8);
     props[ 2 ].num_vals = 1;
     props[ 2 ].vals = &propvalue[ 2 ];
     propvalue[ 3 ].length = strlen("kwinsmhelper");
     propvalue[ 3 ].value = (SmPointer)"kwinsmhelper";
     props[ 3 ].name = const_cast< char* >(SmProgram);
     props[ 3 ].type = const_cast< char* >(SmARRAY8);
     props[ 3 ].num_vals = 1;
     props[ 3 ].vals = &propvalue[ 3 ];
     propvalue[ 4 ].length = 0;
     propvalue[ 4 ].value = (SmPointer)("");
     props[ 4 ].name = const_cast< char* >(SmCloneCommand);
     props[ 4 ].type = const_cast< char* >(SmLISTofARRAY8);
     props[ 4 ].num_vals = 1;
     props[ 4 ].vals = &propvalue[ 4 ];
     SmProp* p[ 5 ] = { &props[ 0 ], &props[ 1 ], &props[ 2 ], &props[ 3 ], &props[ 4 ] };
     SmcSetProperties(conn, 5, p);
     notifier = new QSocketNotifier(IceConnectionNumber(SmcGetIceConnection(conn)),
                                    QSocketNotifier::Read, this);
     connect(notifier, SIGNAL(activated(int)), SLOT(processData()));
 }
 
 SessionSaveDoneHelper::~SessionSaveDoneHelper()
 {
     close();
 }
 
 void SessionSaveDoneHelper::close()
 {
     if (conn != NULL) {
         delete notifier;
         SmcCloseConnection(conn, 0, NULL);
     }
     conn = NULL;
 }
 
 void SessionSaveDoneHelper::processData()
 {
     if (conn != NULL)
         IceProcessMessages(SmcGetIceConnection(conn), 0, 0);
 }
 
 void Workspace::sessionSaveDone()
 {
     session_saving = false;
     //remove sessionInteract flag from all clients
     foreach (Client * c, clients) {
         c->setSessionInteract(false);
     }
 }
 
 } // namespace
 
diff --git a/sm.h b/sm.h
index 4c5fda6e0..529187d84 100644
--- a/sm.h
+++ b/sm.h
@@ -1,102 +1,103 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SM_H
 #define KWIN_SM_H
 
 #include <QDataStream>
 #include <kwinglobals.h>
 #include <QStringList>
 #include <netwm_def.h>
 #include <QRect>
 
 #include <X11/SM/SMlib.h>
 #include <fixx11h.h>
 
 class QSocketNotifier;
 
 namespace KWin
 {
 
 class Client;
 
 struct SessionInfo {
     QByteArray sessionId;
     QByteArray windowRole;
+    QByteArray wmCommand;
     QByteArray wmClientMachine;
     QByteArray resourceName;
     QByteArray resourceClass;
 
     QRect geometry;
     QRect restore;
     QRect fsrestore;
     int maximized;
     int fullscreen;
     int desktop;
     bool minimized;
     bool onAllDesktops;
     bool shaded;
     bool keepAbove;
     bool keepBelow;
     bool skipTaskbar;
     bool skipPager;
     bool skipSwitcher;
     bool noBorder;
     NET::WindowType windowType;
     QString shortcut;
     bool active; // means 'was active in the saved session'
     int stackingOrder;
     float opacity;
     int tabGroup; // Unique identifier for the client group that this window is in
 
     Client* tabGroupClient; // The first client created that has an identical identifier
     QStringList activities;
 };
 
 
 enum SMSavePhase {
     SMSavePhase0,     // saving global state in "phase 0"
     SMSavePhase2,     // saving window state in phase 2
     SMSavePhase2Full  // complete saving in phase2, there was no phase 0
 };
 
 class KWIN_EXPORT SessionSaveDoneHelper
     : public QObject
 {
     Q_OBJECT
 public:
     SessionSaveDoneHelper();
     virtual ~SessionSaveDoneHelper();
     SmcConn connection() const {
         return conn;
     }
     void saveDone();
     void close();
 private Q_SLOTS:
     void processData();
 private:
     QSocketNotifier* notifier;
     SmcConn conn;
 };
 
 } // namespace
 
 #endif
diff --git a/toplevel.cpp b/toplevel.cpp
index af368b5fb..4a7ec6d1d 100644
--- a/toplevel.cpp
+++ b/toplevel.cpp
@@ -1,514 +1,527 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "toplevel.h"
 
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "atoms.h"
 #include "client.h"
 #include "client_machine.h"
 #include "effects.h"
 #include "screens.h"
 #include "shadow.h"
 #include "xcbutils.h"
 
 #include <KWayland/Server/surface_interface.h>
 
 #include <QDebug>
 
 namespace KWin
 {
 
 Toplevel::Toplevel()
     : m_visual(XCB_NONE)
     , bit_depth(24)
     , info(NULL)
     , ready_for_painting(true)
     , m_isDamaged(false)
     , m_client()
     , damage_handle(None)
     , is_shape(false)
     , effect_window(NULL)
     , m_clientMachine(new ClientMachine(this))
     , wmClientLeaderWin(0)
     , unredirect(false)
     , unredirectSuspend(false)
     , m_damageReplyPending(false)
     , m_screen(0)
     , m_skipCloseAnimation(false)
 {
     connect(this, SIGNAL(damaged(KWin::Toplevel*,QRect)), SIGNAL(needsRepaint()));
     connect(screens(), SIGNAL(changed()), SLOT(checkScreen()));
     connect(screens(), SIGNAL(countChanged(int,int)), SLOT(checkScreen()));
     setupCheckScreenConnection();
 }
 
 Toplevel::~Toplevel()
 {
     assert(damage_handle == None);
     delete info;
 }
 
 QDebug& operator<<(QDebug& stream, const Toplevel* cl)
 {
     if (cl == NULL)
         return stream << "\'NULL\'";
     cl->debug(stream);
     return stream;
 }
 
 QDebug& operator<<(QDebug& stream, const ToplevelList& list)
 {
     stream << "LIST:(";
     bool first = true;
     for (ToplevelList::ConstIterator it = list.begin();
             it != list.end();
             ++it) {
         if (!first)
             stream << ":";
         first = false;
         stream << *it;
     }
     stream << ")";
     return stream;
 }
 
 QRect Toplevel::decorationRect() const
 {
     return rect();
 }
 
 void Toplevel::detectShape(Window id)
 {
     const bool wasShape = is_shape;
     is_shape = Xcb::Extensions::self()->hasShape(id);
     if (wasShape != is_shape) {
         emit shapedChanged();
     }
 }
 
 // used only by Deleted::copy()
 void Toplevel::copyToDeleted(Toplevel* c)
 {
     geom = c->geom;
     m_visual = c->m_visual;
     bit_depth = c->bit_depth;
     info = c->info;
     m_client.reset(c->m_client, false);
     ready_for_painting = c->ready_for_painting;
     damage_handle = None;
     damage_region = c->damage_region;
     repaints_region = c->repaints_region;
     is_shape = c->is_shape;
     effect_window = c->effect_window;
     if (effect_window != NULL)
         effect_window->setWindow(this);
     resource_name = c->resourceName();
     resource_class = c->resourceClass();
     m_clientMachine = c->m_clientMachine;
     m_clientMachine->setParent(this);
     wmClientLeaderWin = c->wmClientLeader();
     opaque_region = c->opaqueRegion();
     m_screen = c->m_screen;
     m_skipCloseAnimation = c->m_skipCloseAnimation;
     m_internalFBO = c->m_internalFBO;
 }
 
 // before being deleted, remove references to everything that's now
 // owner by Deleted
 void Toplevel::disownDataPassedToDeleted()
 {
     info = NULL;
 }
 
 QRect Toplevel::visibleRect() const
 {
     QRect r = decorationRect();
     if (hasShadow() && !shadow()->shadowRegion().isEmpty()) {
         r |= shadow()->shadowRegion().boundingRect();
     }
     return r.translated(geometry().topLeft());
 }
 
 Xcb::Property Toplevel::fetchWmClientLeader() const
 {
     return Xcb::Property(false, window(), atoms->wm_client_leader, XCB_ATOM_WINDOW, 0, 10000);
 }
 
 void Toplevel::readWmClientLeader(Xcb::Property &prop)
 {
     wmClientLeaderWin = prop.value<xcb_window_t>(window());
 }
 
 void Toplevel::getWmClientLeader()
 {
     auto prop = fetchWmClientLeader();
     readWmClientLeader(prop);
 }
 
 /*!
   Returns sessionId for this client,
   taken either from its window or from the leader window.
  */
 QByteArray Toplevel::sessionId() const
 {
     QByteArray result = Xcb::StringProperty(window(), atoms->sm_client_id);
     if (result.isEmpty() && wmClientLeaderWin && wmClientLeaderWin != window())
         result = Xcb::StringProperty(wmClientLeaderWin, atoms->sm_client_id);
     return result;
 }
 
+/*!
+  Returns command property for this client,
+  taken either from its window or from the leader window.
+ */
+QByteArray Toplevel::wmCommand()
+{
+    QByteArray result = Xcb::StringProperty(window(), XCB_ATOM_WM_COMMAND);
+    if (result.isEmpty() && wmClientLeaderWin && wmClientLeaderWin != window())
+        result = Xcb::StringProperty(wmClientLeaderWin, XCB_ATOM_WM_COMMAND);
+    result.replace(0, ' ');
+    return result;
+}
+
 void Toplevel::getWmClientMachine()
 {
     m_clientMachine->resolve(window(), wmClientLeader());
 }
 
 /*!
   Returns client machine for this client,
   taken either from its window or from the leader window.
 */
 QByteArray Toplevel::wmClientMachine(bool use_localhost) const
 {
     if (!m_clientMachine) {
         // this should never happen
         return QByteArray();
     }
     if (use_localhost && m_clientMachine->isLocal()) {
         // special name for the local machine (localhost)
         return ClientMachine::localhost();
     }
     return m_clientMachine->hostName();
 }
 
 /*!
   Returns client leader window for this client.
   Returns the client window itself if no leader window is defined.
 */
 Window Toplevel::wmClientLeader() const
 {
     if (wmClientLeaderWin)
         return wmClientLeaderWin;
     return window();
 }
 
 void Toplevel::getResourceClass()
 {
     setResourceClass(QByteArray(info->windowClassName()).toLower(), QByteArray(info->windowClassClass()).toLower());
 }
 
 void Toplevel::setResourceClass(const QByteArray &name, const QByteArray &className)
 {
     resource_name  = name;
     resource_class = className;
     emit windowClassChanged();
 }
 
 double Toplevel::opacity() const
 {
     if (info->opacity() == 0xffffffff)
         return 1.0;
     return info->opacity() * 1.0 / 0xffffffff;
 }
 
 void Toplevel::setOpacity(double new_opacity)
 {
     double old_opacity = opacity();
     new_opacity = qBound(0.0, new_opacity, 1.0);
     if (old_opacity == new_opacity)
         return;
     info->setOpacity(static_cast< unsigned long >(new_opacity * 0xffffffff));
     if (compositing()) {
         addRepaintFull();
         emit opacityChanged(this, old_opacity);
     }
 }
 
 void Toplevel::setReadyForPainting()
 {
     if (!ready_for_painting) {
         ready_for_painting = true;
         if (compositing()) {
             addRepaintFull();
             emit windowShown(this);
             if (Client *cl = dynamic_cast<Client*>(this)) {
                 if (cl->tabGroup() && cl->tabGroup()->current() == cl)
                     cl->tabGroup()->setCurrent(cl, true);
             }
         }
     }
 }
 
 void Toplevel::deleteEffectWindow()
 {
     delete effect_window;
     effect_window = NULL;
 }
 
 void Toplevel::checkScreen()
 {
     if (screens()->count() == 1) {
         if (m_screen != 0) {
             m_screen = 0;
             emit screenChanged();
         }
         return;
     }
     const int s = screens()->number(geometry().center());
     if (s != m_screen) {
         m_screen = s;
         emit screenChanged();
     }
 }
 
 void Toplevel::setupCheckScreenConnection()
 {
     connect(this, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SLOT(checkScreen()));
     connect(this, SIGNAL(geometryChanged()), SLOT(checkScreen()));
     checkScreen();
 }
 
 void Toplevel::removeCheckScreenConnection()
 {
     disconnect(this, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), this, SLOT(checkScreen()));
     disconnect(this, SIGNAL(geometryChanged()), this, SLOT(checkScreen()));
 }
 
 int Toplevel::screen() const
 {
     return m_screen;
 }
 
 bool Toplevel::isOnScreen(int screen) const
 {
     return screens()->geometry(screen).intersects(geometry());
 }
 
 bool Toplevel::isOnActiveScreen() const
 {
     return isOnScreen(screens()->current());
 }
 
 void Toplevel::getShadow()
 {
     QRect dirtyRect;  // old & new shadow region
     const QRect oldVisibleRect = visibleRect();
     if (hasShadow()) {
         dirtyRect = shadow()->shadowRegion().boundingRect();
         effectWindow()->sceneWindow()->shadow()->updateShadow();
     } else {
         Shadow::createShadow(this);
     }
     if (hasShadow())
         dirtyRect |= shadow()->shadowRegion().boundingRect();
     if (oldVisibleRect != visibleRect())
         emit paddingChanged(this, oldVisibleRect);
     if (dirtyRect.isValid()) {
         dirtyRect.translate(pos());
         addLayerRepaint(dirtyRect);
     }
 }
 
 bool Toplevel::hasShadow() const
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         return effectWindow()->sceneWindow()->shadow() != NULL;
     }
     return false;
 }
 
 Shadow *Toplevel::shadow()
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         return effectWindow()->sceneWindow()->shadow();
     } else {
         return NULL;
     }
 }
 
 const Shadow *Toplevel::shadow() const
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         return effectWindow()->sceneWindow()->shadow();
     } else {
         return NULL;
     }
 }
 
 bool Toplevel::wantsShadowToBeRendered() const
 {
     return true;
 }
 
 void Toplevel::getWmOpaqueRegion()
 {
     const auto rects = info->opaqueRegion();
     QRegion new_opaque_region;
     for (const auto &r : rects) {
         new_opaque_region += QRect(r.pos.x, r.pos.y, r.size.width, r.size.height);
     }
 
     opaque_region = new_opaque_region;
 }
 
 bool Toplevel::isClient() const
 {
     return false;
 }
 
 bool Toplevel::isDeleted() const
 {
     return false;
 }
 
 bool Toplevel::isOnCurrentActivity() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return true;
     }
     return isOnActivity(Activities::self()->current());
 #else
     return true;
 #endif
 }
 
 void Toplevel::elevate(bool elevate)
 {
     if (!effectWindow()) {
         return;
     }
     effectWindow()->elevate(elevate);
     addWorkspaceRepaint(visibleRect());
 }
 
 pid_t Toplevel::pid() const
 {
     return info->pid();
 }
 
 xcb_window_t Toplevel::frameId() const
 {
     return m_client;
 }
 
 Xcb::Property Toplevel::fetchSkipCloseAnimation() const
 {
     return Xcb::Property(false, window(), atoms->kde_skip_close_animation, XCB_ATOM_CARDINAL, 0, 1);
 }
 
 void Toplevel::readSkipCloseAnimation(Xcb::Property &property)
 {
     setSkipCloseAnimation(property.toBool());
 }
 
 void Toplevel::getSkipCloseAnimation()
 {
     Xcb::Property property = fetchSkipCloseAnimation();
     readSkipCloseAnimation(property);
 }
 
 bool Toplevel::skipsCloseAnimation() const
 {
     return m_skipCloseAnimation;
 }
 
 void Toplevel::setSkipCloseAnimation(bool set)
 {
     if (set == m_skipCloseAnimation) {
         return;
     }
     m_skipCloseAnimation = set;
     emit skipCloseAnimationChanged();
 }
 
 void Toplevel::setSurface(KWayland::Server::SurfaceInterface *surface)
 {
     if (m_surface == surface) {
         return;
     }
     using namespace KWayland::Server;
     if (m_surface) {
         disconnect(m_surface, &SurfaceInterface::damaged, this, &Toplevel::addDamage);
     }
     m_surface = surface;
     connect(m_surface, &SurfaceInterface::damaged, this, &Toplevel::addDamage);
     connect(m_surface, &SurfaceInterface::destroyed, this,
         [this] {
             m_surface = nullptr;
         }
     );
 }
 
 void Toplevel::addDamage(const QRegion &damage)
 {
     m_isDamaged = true;
     damage_region += damage;
     for (const QRect &r : damage.rects()) {
         emit damaged(this, r);
     }
 }
 
 QByteArray Toplevel::windowRole() const
 {
     return QByteArray(info->windowRole());
 }
 
 void Toplevel::setDepth(int depth)
 {
     if (bit_depth == depth) {
         return;
     }
     const bool oldAlpha = hasAlpha();
     bit_depth = depth;
     if (oldAlpha != hasAlpha()) {
         emit hasAlphaChanged();
     }
 }
 
 QRegion Toplevel::inputShape() const
 {
     if (m_surface) {
         return m_surface->input();
     } else {
         // TODO: maybe also for X11?
         return QRegion();
     }
 }
 
 void Toplevel::setInternalFramebufferObject(const QSharedPointer<QOpenGLFramebufferObject> &fbo)
 {
     if (m_internalFBO != fbo) {
         discardWindowPixmap();
         m_internalFBO = fbo;
     }
     setDepth(32);
 }
 
 QMatrix4x4 Toplevel::inputTransformation() const
 {
     QMatrix4x4 m;
     m.translate(-x(), -y());
     return m;
 }
 
 } // namespace
 
diff --git a/toplevel.h b/toplevel.h
index 313385130..91eee5f26 100644
--- a/toplevel.h
+++ b/toplevel.h
@@ -1,804 +1,805 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_TOPLEVEL_H
 #define KWIN_TOPLEVEL_H
 
 // kwin
 #include "input.h"
 #include "utils.h"
 #include "virtualdesktops.h"
 #include "xcbutils.h"
 // KDE
 #include <NETWM>
 // Qt
 #include <QObject>
 #include <QMatrix4x4>
 // xcb
 #include <xcb/damage.h>
 #include <xcb/xfixes.h>
 // XLib
 #include <X11/Xlib.h>
 #include <fixx11h.h>
 // system
 #include <assert.h>
 // c++
 #include <functional>
 
 class QOpenGLFramebufferObject;
 
 namespace KWayland
 {
 namespace Server
 {
 class SurfaceInterface;
 }
 }
 
 namespace KWin
 {
 
 class ClientMachine;
 class EffectWindowImpl;
 class Shadow;
 
 /**
  * Enum to describe the reason why a Toplevel has to be released.
  */
 enum class ReleaseReason {
     Release, ///< Normal Release after e.g. an Unmap notify event (window still valid)
     Destroyed, ///< Release after an Destroy notify event (window no longer valid)
     KWinShutsDown ///< Release on KWin Shutdown (window still valid)
 };
 
 class KWIN_EXPORT Toplevel
     : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool alpha READ hasAlpha NOTIFY hasAlphaChanged)
     Q_PROPERTY(qulonglong frameId READ frameId)
     Q_PROPERTY(QRect geometry READ geometry NOTIFY geometryChanged)
     Q_PROPERTY(QRect visibleRect READ visibleRect)
     Q_PROPERTY(int height READ height)
     Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
     Q_PROPERTY(QPoint pos READ pos)
     Q_PROPERTY(int screen READ screen NOTIFY screenChanged)
     Q_PROPERTY(QSize size READ size)
     Q_PROPERTY(int width READ width)
     Q_PROPERTY(qulonglong windowId READ window CONSTANT)
     Q_PROPERTY(int x READ x)
     Q_PROPERTY(int y READ y)
     Q_PROPERTY(int desktop READ desktop)
     /**
      * Whether the window is on all desktops. That is desktop is -1.
      **/
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
     Q_PROPERTY(QRect rect READ rect)
     Q_PROPERTY(QPoint clientPos READ clientPos)
     Q_PROPERTY(QSize clientSize READ clientSize)
     Q_PROPERTY(QByteArray resourceName READ resourceName NOTIFY windowClassChanged)
     Q_PROPERTY(QByteArray resourceClass READ resourceClass NOTIFY windowClassChanged)
     Q_PROPERTY(QByteArray windowRole READ windowRole NOTIFY windowRoleChanged)
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool desktopWindow READ isDesktop)
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dock READ isDock)
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool toolbar READ isToolbar)
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool menu READ isMenu)
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool normalWindow READ isNormalWindow)
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dialog READ isDialog)
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool splash READ isSplash)
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool utility READ isUtility)
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dropdownMenu READ isDropdownMenu)
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool popupMenu READ isPopupMenu)
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool tooltip READ isTooltip)
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool notification READ isNotification)
     /**
      * Returns whether the window is an On Screen Display.
      */
     Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay)
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool comboBox READ isComboBox)
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dndIcon READ isDNDIcon)
     /**
      * Returns the NETWM window type
      * See http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(int windowType READ windowType)
     Q_PROPERTY(QStringList activities READ activities NOTIFY activitiesChanged)
     /**
      * Whether this Toplevel is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      **/
     Q_PROPERTY(bool managed READ isClient CONSTANT)
     /**
      * Whether this Toplevel represents an already deleted window and only kept for the compositor for animations.
      **/
     Q_PROPERTY(bool deleted READ isDeleted CONSTANT)
     /**
      * Whether the window has an own shape
      **/
     Q_PROPERTY(bool shaped READ shape NOTIFY shapedChanged)
     /**
      * Whether the window does not want to be animated on window close.
      * There are legit reasons for this like a screenshot application which does not want it's
      * window being captured.
      **/
     Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation WRITE setSkipCloseAnimation NOTIFY skipCloseAnimationChanged)
     /**
      * The Id of the Wayland Surface associated with this Toplevel.
      * On X11 only setups the value is @c 0.
      **/
     Q_PROPERTY(quint32 surfaceId READ surfaceId NOTIFY surfaceIdChanged)
 
     /**
      * Interface to the Wayland Surface.
      * Relevant only in Wayland, in X11 it will be nullptr
      */
     Q_PROPERTY(KWayland::Server::SurfaceInterface *surface READ surface)
 
 public:
     explicit Toplevel();
     virtual xcb_window_t frameId() const;
     virtual xcb_window_t window() const;
     QRect geometry() const;
     QSize size() const;
     QPoint pos() const;
     QRect rect() const;
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     bool isOnScreen(int screen) const;   // true if it's at least partially there
     bool isOnActiveScreen() const;
     int screen() const; // the screen where the center is
     virtual QPoint clientPos() const = 0; // inside of geometry()
     /**
      * Describes how the client's content maps to the window geometry including the frame.
      * The default implementation is a 1:1 mapping meaning the frame is part of the content.
      **/
     virtual QPoint clientContentPos() const;
     virtual QSize clientSize() const = 0;
     virtual QRect visibleRect() const; // the area the window occupies on the screen
     virtual QRect decorationRect() const; // rect including the decoration shadows
     virtual QRect transparentRect() const = 0;
     virtual bool isClient() const;
     virtual bool isDeleted() const;
 
     // prefer isXXX() instead
     // 0 for supported types means default for managed/unmanaged types
     virtual NET::WindowType windowType(bool direct = false, int supported_types = 0) const = 0;
     bool hasNETSupport() const;
     bool isDesktop() const;
     bool isDock() const;
     bool isToolbar() const;
     bool isMenu() const;
     bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient'
     bool isDialog() const;
     bool isSplash() const;
     bool isUtility() const;
     bool isDropdownMenu() const;
     bool isPopupMenu() const; // a context popup, not dropdown, not torn-off
     bool isTooltip() const;
     bool isNotification() const;
     bool isOnScreenDisplay() const;
     bool isComboBox() const;
     bool isDNDIcon() const;
 
     virtual bool isLockScreen() const;
     virtual bool isInputMethod() const;
 
     virtual int desktop() const = 0;
     virtual QStringList activities() const = 0;
     bool isOnDesktop(int d) const;
     bool isOnActivity(const QString &activity) const;
     bool isOnCurrentDesktop() const;
     bool isOnCurrentActivity() const;
     bool isOnAllDesktops() const;
     bool isOnAllActivities() const;
 
     virtual QByteArray windowRole() const;
     QByteArray sessionId() const;
     QByteArray resourceName() const;
     QByteArray resourceClass() const;
+    QByteArray wmCommand();
     QByteArray wmClientMachine(bool use_localhost) const;
     const ClientMachine *clientMachine() const;
     Window wmClientLeader() const;
     pid_t pid() const;
     static bool resourceMatch(const Toplevel* c1, const Toplevel* c2);
 
     bool readyForPainting() const; // true if the window has been already painted its contents
     xcb_visualid_t visual() const;
     bool shape() const;
     QRegion inputShape() const;
     virtual void setOpacity(double opacity);
     virtual double opacity() const;
     int depth() const;
     bool hasAlpha() const;
     virtual bool setupCompositing();
     virtual void finishCompositing(ReleaseReason releaseReason = ReleaseReason::Release);
     bool updateUnredirectedState();
     bool unredirected() const;
     void suspendUnredirect(bool suspend);
     Q_INVOKABLE void addRepaint(const QRect& r);
     Q_INVOKABLE void addRepaint(const QRegion& r);
     Q_INVOKABLE void addRepaint(int x, int y, int w, int h);
     Q_INVOKABLE void addLayerRepaint(const QRect& r);
     Q_INVOKABLE void addLayerRepaint(const QRegion& r);
     Q_INVOKABLE void addLayerRepaint(int x, int y, int w, int h);
     Q_INVOKABLE virtual void addRepaintFull();
     // these call workspace->addRepaint(), but first transform the damage if needed
     void addWorkspaceRepaint(const QRect& r);
     void addWorkspaceRepaint(int x, int y, int w, int h);
     QRegion repaints() const;
     void resetRepaints();
     QRegion damage() const;
     void resetDamage();
     EffectWindowImpl* effectWindow();
     const EffectWindowImpl* effectWindow() const;
     /**
      * Window will be temporarily painted as if being at the top of the stack.
      * Only available if Compositor is active, if not active, this method is a no-op.
      **/
     void elevate(bool elevate);
 
     /**
      * @returns Whether the Toplevel has a Shadow or not
      * @see shadow
      **/
     bool hasShadow() const;
     /**
      * Returns the pointer to the Toplevel's Shadow. A Shadow
      * is only available if Compositing is enabled and the corresponding X window
      * has the Shadow property set.
      * If a shadow is available @link hasShadow returns @c true.
      * @returns The Shadow belonging to this Toplevel, may be @c NULL.
      * @see hasShadow
      **/
     const Shadow *shadow() const;
     Shadow *shadow();
     /**
      * Updates the Shadow associated with this Toplevel from X11 Property.
      * Call this method when the Property changes or Compositing is started.
      **/
     void getShadow();
     /**
      * Whether the Toplevel currently wants the shadow to be rendered. Default
      * implementation always returns @c true.
      **/
     virtual bool wantsShadowToBeRendered() const;
 
     /**
      * This method returns the area that the Toplevel window reports to be opaque.
      * It is supposed to only provide valuable information if @link hasAlpha is @c true .
      * @see hasAlpha
      **/
     const QRegion& opaqueRegion() const;
 
     virtual Layer layer() const = 0;
 
     /**
      * Resets the damage state and sends a request for the damage region.
      * A call to this function must be followed by a call to getDamageRegionReply(),
      * or the reply will be leaked.
      *
      * Returns true if the window was damaged, and false otherwise.
      */
     bool resetAndFetchDamage();
 
     /**
      * Gets the reply from a previous call to resetAndFetchDamage().
      * Calling this function is a no-op if there is no pending reply.
      * Call damage() to return the fetched region.
      */
     void getDamageRegionReply();
 
     bool skipsCloseAnimation() const;
     void setSkipCloseAnimation(bool set);
 
     quint32 surfaceId() const;
     KWayland::Server::SurfaceInterface *surface() const;
     void setSurface(KWayland::Server::SurfaceInterface *surface);
 
     virtual void setInternalFramebufferObject(const QSharedPointer<QOpenGLFramebufferObject> &fbo);
     const QSharedPointer<QOpenGLFramebufferObject> &internalFramebufferObject() const;
 
     /**
      * @returns Transformation to map from global to window coordinates.
      *
      * Default implementation returns a translation on negative pos().
      * @see pos
      **/
     virtual QMatrix4x4 inputTransformation() const;
 
     /**
      * @brief Finds the Toplevel matching the condition expressed in @p func in @p list.
      *
      * The method is templated to operate on either a list of Toplevels or on a list of
      * a subclass type of Toplevel.
      * @param list The list to search in
      * @param func The condition function (compare std::find_if)
      * @return T* The found Toplevel or @c null if there is no matching Toplevel
      */
     template <class T, class U>
     static T *findInList(const QList<T*> &list, std::function<bool (const U*)> func);
 
 Q_SIGNALS:
     void opacityChanged(KWin::Toplevel* toplevel, qreal oldOpacity);
     void damaged(KWin::Toplevel* toplevel, const QRect& damage);
     void propertyNotify(KWin::Toplevel* toplevel, long a);
     void geometryChanged();
     void geometryShapeChanged(KWin::Toplevel* toplevel, const QRect& old);
     void paddingChanged(KWin::Toplevel* toplevel, const QRect& old);
     void windowClosed(KWin::Toplevel* toplevel, KWin::Deleted* deleted);
     void windowShown(KWin::Toplevel* toplevel);
     void windowHidden(KWin::Toplevel* toplevel);
     /**
      * Signal emitted when the window's shape state changed. That is if it did not have a shape
      * and received one or if the shape was withdrawn. Think of Chromium enabling/disabling KWin's
      * decoration.
      **/
     void shapedChanged();
     /**
      * Emitted whenever the state changes in a way, that the Compositor should
      * schedule a repaint of the scene.
      **/
     void needsRepaint();
     void activitiesChanged(KWin::Toplevel* toplevel);
     /**
      * Emitted whenever the Toplevel's screen changes. This can happen either in consequence to
      * a screen being removed/added or if the Toplevel's geometry changes.
      * @since 4.11
      **/
     void screenChanged();
     void skipCloseAnimationChanged();
     /**
      * Emitted whenever the window role of the window changes.
      * @since 5.0
      **/
     void windowRoleChanged();
     /**
      * Emitted whenever the window class name or resource name of the window changes.
      * @since 5.0
      **/
     void windowClassChanged();
     /**
      * Emitted when a Wayland Surface gets associated with this Toplevel.
      * @since 5.3
      **/
     void surfaceIdChanged(quint32);
     /**
      * @since 5.4
      **/
     void hasAlphaChanged();
 
 protected Q_SLOTS:
     /**
      * Checks whether the screen number for this Toplevel changed and updates if needed.
      * Any method changing the geometry of the Toplevel should call this method.
      **/
     void checkScreen();
     void setupCheckScreenConnection();
     void removeCheckScreenConnection();
     void setReadyForPainting();
 
 protected:
     virtual ~Toplevel();
     void setWindowHandles(xcb_window_t client);
     void detectShape(Window id);
     virtual void propertyNotifyEvent(xcb_property_notify_event_t *e);
     virtual void damageNotifyEvent();
     virtual void clientMessageEvent(xcb_client_message_event_t *e);
     void discardWindowPixmap();
     void addDamageFull();
     virtual void addDamage(const QRegion &damage);
     Xcb::Property fetchWmClientLeader() const;
     void readWmClientLeader(Xcb::Property &p);
     void getWmClientLeader();
     void getWmClientMachine();
     /**
      * @returns Whether there is a compositor and it is active.
      **/
     bool compositing() const;
 
     /**
      * This function fetches the opaque region from this Toplevel.
      * Will only be called on corresponding property changes and for initialization.
      **/
     void getWmOpaqueRegion();
 
     void getResourceClass();
     void setResourceClass(const QByteArray &name, const QByteArray &className = QByteArray());
     Xcb::Property fetchSkipCloseAnimation() const;
     void readSkipCloseAnimation(Xcb::Property &prop);
     void getSkipCloseAnimation();
     virtual void debug(QDebug& stream) const = 0;
     void copyToDeleted(Toplevel* c);
     void disownDataPassedToDeleted();
     friend QDebug& operator<<(QDebug& stream, const Toplevel*);
     void deleteEffectWindow();
     virtual bool shouldUnredirect() const = 0;
     void setDepth(int depth);
     QRect geom;
     xcb_visualid_t m_visual;
     int bit_depth;
     NETWinInfo* info;
     bool ready_for_painting;
     QRegion repaints_region; // updating, repaint just requires repaint of that area
     QRegion layer_repaints_region;
 
 protected:
     bool m_isDamaged;
 
 private:
     // when adding new data members, check also copyToDeleted()
     Xcb::Window m_client;
     xcb_damage_damage_t damage_handle;
     QRegion damage_region; // damage is really damaged window (XDamage) and texture needs
     bool is_shape;
     EffectWindowImpl* effect_window;
     QByteArray resource_name;
     QByteArray resource_class;
     ClientMachine *m_clientMachine;
     WId wmClientLeaderWin;
     bool unredirect;
     bool unredirectSuspend; // when unredirected, but pixmap is needed temporarily
     bool m_damageReplyPending;
     QRegion opaque_region;
     xcb_xfixes_fetch_region_cookie_t m_regionCookie;
     int m_screen;
     bool m_skipCloseAnimation;
     quint32 m_surfaceId = 0;
     KWayland::Server::SurfaceInterface *m_surface = nullptr;
     /**
      * An FBO object KWin internal windows might render to.
      **/
     QSharedPointer<QOpenGLFramebufferObject> m_internalFBO;
     // when adding new data members, check also copyToDeleted()
 };
 
 inline xcb_window_t Toplevel::window() const
 {
     return m_client;
 }
 
 inline void Toplevel::setWindowHandles(xcb_window_t w)
 {
     assert(!m_client.isValid() && w != XCB_WINDOW_NONE);
     m_client.reset(w, false);
 }
 
 inline QRect Toplevel::geometry() const
 {
     return geom;
 }
 
 inline QSize Toplevel::size() const
 {
     return geom.size();
 }
 
 inline QPoint Toplevel::pos() const
 {
     return geom.topLeft();
 }
 
 inline int Toplevel::x() const
 {
     return geom.x();
 }
 
 inline int Toplevel::y() const
 {
     return geom.y();
 }
 
 inline int Toplevel::width() const
 {
     return geom.width();
 }
 
 inline int Toplevel::height() const
 {
     return geom.height();
 }
 
 inline QRect Toplevel::rect() const
 {
     return QRect(0, 0, width(), height());
 }
 
 inline bool Toplevel::readyForPainting() const
 {
     return ready_for_painting;
 }
 
 inline xcb_visualid_t Toplevel::visual() const
 {
     return m_visual;
 }
 
 inline bool Toplevel::isDesktop() const
 {
     return windowType() == NET::Desktop;
 }
 
 inline bool Toplevel::isDock() const
 {
     return windowType() == NET::Dock;
 }
 
 inline bool Toplevel::isMenu() const
 {
     return windowType() == NET::Menu;
 }
 
 inline bool Toplevel::isToolbar() const
 {
     return windowType() == NET::Toolbar;
 }
 
 inline bool Toplevel::isSplash() const
 {
     return windowType() == NET::Splash;
 }
 
 inline bool Toplevel::isUtility() const
 {
     return windowType() == NET::Utility;
 }
 
 inline bool Toplevel::isDialog() const
 {
     return windowType() == NET::Dialog;
 }
 
 inline bool Toplevel::isNormalWindow() const
 {
     return windowType() == NET::Normal;
 }
 
 inline bool Toplevel::isDropdownMenu() const
 {
     return windowType() == NET::DropdownMenu;
 }
 
 inline bool Toplevel::isPopupMenu() const
 {
     return windowType() == NET::PopupMenu;
 }
 
 inline bool Toplevel::isTooltip() const
 {
     return windowType() == NET::Tooltip;
 }
 
 inline bool Toplevel::isNotification() const
 {
     return windowType() == NET::Notification;
 }
 
 inline bool Toplevel::isOnScreenDisplay() const
 {
     return windowType() == NET::OnScreenDisplay;
 }
 
 inline bool Toplevel::isComboBox() const
 {
     return windowType() == NET::ComboBox;
 }
 
 inline bool Toplevel::isDNDIcon() const
 {
     return windowType() == NET::DNDIcon;
 }
 
 inline bool Toplevel::isLockScreen() const
 {
     return false;
 }
 
 inline bool Toplevel::isInputMethod() const
 {
     return false;
 }
 
 inline QRegion Toplevel::damage() const
 {
     return damage_region;
 }
 
 inline QRegion Toplevel::repaints() const
 {
     return repaints_region.translated(pos()) | layer_repaints_region;
 }
 
 inline bool Toplevel::shape() const
 {
     return is_shape;
 }
 
 inline int Toplevel::depth() const
 {
     return bit_depth;
 }
 
 inline bool Toplevel::hasAlpha() const
 {
     return depth() == 32;
 }
 
 inline const QRegion& Toplevel::opaqueRegion() const
 {
     return opaque_region;
 }
 
 inline
 EffectWindowImpl* Toplevel::effectWindow()
 {
     return effect_window;
 }
 
 inline
 const EffectWindowImpl* Toplevel::effectWindow() const
 {
     return effect_window;
 }
 
 inline bool Toplevel::isOnAllDesktops() const
 {
     return desktop() == NET::OnAllDesktops;
 }
 
 inline bool Toplevel::isOnAllActivities() const
 {
     return activities().isEmpty();
 }
 
 inline bool Toplevel::isOnDesktop(int d) const
 {
     return desktop() == d || /*desk == 0 ||*/ isOnAllDesktops();
 }
 
 inline bool Toplevel::isOnActivity(const QString &activity) const
 {
     return activities().isEmpty() || activities().contains(activity);
 }
 
 inline bool Toplevel::isOnCurrentDesktop() const
 {
     return isOnDesktop(VirtualDesktopManager::self()->current());
 }
 
 inline QByteArray Toplevel::resourceName() const
 {
     return resource_name; // it is always lowercase
 }
 
 inline QByteArray Toplevel::resourceClass() const
 {
     return resource_class; // it is always lowercase
 }
 
 inline bool Toplevel::unredirected() const
 {
     return unredirect;
 }
 
 inline const ClientMachine *Toplevel::clientMachine() const
 {
     return m_clientMachine;
 }
 
 inline quint32 Toplevel::surfaceId() const
 {
     return m_surfaceId;
 }
 
 inline KWayland::Server::SurfaceInterface *Toplevel::surface() const
 {
     return m_surface;
 }
 
 inline const QSharedPointer<QOpenGLFramebufferObject> &Toplevel::internalFramebufferObject() const
 {
     return m_internalFBO;
 }
 
 inline QPoint Toplevel::clientContentPos() const
 {
     return QPoint(0, 0);
 }
 
 template <class T, class U>
 inline T *Toplevel::findInList(const QList<T*> &list, std::function<bool (const U*)> func)
 {
     static_assert(std::is_base_of<U, T>::value,
                  "U must be derived from T");
     const auto it = std::find_if(list.begin(), list.end(), func);
     if (it == list.end()) {
         return nullptr;
     }
     return *it;
 }
 
 QDebug& operator<<(QDebug& stream, const Toplevel*);
 QDebug& operator<<(QDebug& stream, const ToplevelList&);
 
 } // namespace
 Q_DECLARE_METATYPE(KWin::Toplevel*)
 
 #endif