diff --git a/libtaskmanager/abstracttasksmodel.h b/libtaskmanager/abstracttasksmodel.h
index 9d359d84..8472388e 100644
--- a/libtaskmanager/abstracttasksmodel.h
+++ b/libtaskmanager/abstracttasksmodel.h
@@ -1,253 +1,254 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef ABSTRACTTASKSMODEL_H
 #define ABSTRACTTASKSMODEL_H
 
 #include "abstracttasksmodeliface.h"
 
 #include <QAbstractListModel>
 
 #include "taskmanager_export.h"
 
 namespace TaskManager
 {
 
 /**
  * @short An abstract base class for (flat) tasks models.
  *
  * This class serves as abstract base class for flat tasks model implementations.
  * It provides data roles and no-op default implementations of methods in the
  * AbstractTasksModelIface interface.
  *
  * @author Eike Hein <hein@kde.org>
  **/
 
 class TASKMANAGER_EXPORT AbstractTasksModel : public QAbstractListModel,
     public AbstractTasksModelIface
 {
     Q_OBJECT
 
     Q_ENUMS(AdditionalRoles)
 
 public:
     enum AdditionalRoles {
         AppId = Qt::UserRole + 1, /**< KService storage id (.desktop name sans extension). */
         AppName,          /**< Application name. */
         GenericName,      /**< Generic application name. */
         LauncherUrl,      /**< URL that can be used to launch this application (.desktop or executable). */
+        LauncherUrlWithoutIcon, /**< Special path to get a launcher URL while skipping fallback icon encoding. Used as speed optimization. */
         LegacyWinIdList,  /**< X11 window ids. Stopgap until we have something better. */
         MimeType,         /**< MIME type for this task (window, window group), needed for DND. */
         MimeData,         /**< Data for MimeType. */
         IsWindow,         /**< This is a window task. */
         IsStartup,        /**< This is a startup task. */
         IsLauncher,       /**< This is a launcher task. */
         IsGroupParent,    /**< This is a parent item for a group of child tasks. */
         IsGroupable,      /**< Whether this task is being ignored by grouping or not. */
         IsActive,         /**< This is the currently active task. */
         IsClosable,       /**< requestClose (see below) available. */
         IsMovable,        /**< requestMove (see below) available. */
         IsResizable,      /**< requestResize (see below) available. */
         IsMaximizable,    /**< requestToggleMaximize (see below) available. */
         IsMaximized,      /**< Task (i.e. window) is maximized. */
         IsMinimizable,    /**< requestToggleMinimize (see below) available. */
         IsMinimized,      /**< Task (i.e. window) is minimized. */
         IsKeepAbove,      /**< Task (i.e. window) is keep-above. */
         IsKeepBelow,      /**< Task (i.e. window) is keep-below. */
         IsFullScreenable, /**< requestToggleFullScreen (see below) available. */
         IsFullScreen,     /**< Task (i.e. window) is fullscreen. */
         IsShadeable,      /**< requestToggleShade (see below) available. */
         IsShaded,         /**< Task (i.e. window) is shaded. */
         IsVirtualDesktopChangeable, /**< requestVirtualDesktop (see below) available. */
         VirtualDesktop,   /**< Virtual desktop for the task (i.e. window). */
         IsOnAllVirtualDesktops, /**< Task is on all virtual desktops. */
         Screen,           /**< Screen for the task (i.e. window). */
         Activities,       /**< Activities for the task (i.e. window). */
         IsDemandingAttention, /**< Task is demanding attention. */
         SkipTaskbar       /**< Task desires not to be shown in a user interface. */
     };
 
     explicit AbstractTasksModel(QObject *parent = nullptr);
     virtual ~AbstractTasksModel();
 
     QHash<int, QByteArray> roleNames() const override;
 
     virtual QModelIndex	index(int row, int column = 0, const QModelIndex &parent = QModelIndex()) const;
 
     /**
      * Request activation of the task at the given index. Derived classes are
      * free to interpret the meaning of "activate" themselves depending on
      * the nature and state of the task, e.g. launch or raise a window task.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestActivate(const QModelIndex &index);
 
     /**
      * Request an additional instance of the application backing the task
      * at the given index.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestNewInstance(const QModelIndex &index);
 
     /**
      * Request the task at the given index be closed.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestClose(const QModelIndex &index);
 
     /**
      * Request starting an interactive move for the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestMove(const QModelIndex &index);
 
     /**
      * Request starting an interactive resize for the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be a
      * no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestResize(const QModelIndex &index);
 
     /**
      * Request toggling the minimized state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleMinimized(const QModelIndex &index);
 
     /**
      * Request toggling the maximized state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleMaximized(const QModelIndex &index);
 
     /**
      * Request toggling the keep-above state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleKeepAbove(const QModelIndex &index);
 
     /**
      * Request toggling the keep-below state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleKeepBelow(const QModelIndex &index);
 
     /**
      * Request toggling the fullscreen state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleFullScreen(const QModelIndex &index);
 
     /**
      * Request toggling the shaded state of the task at the given index.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      **/
     virtual void requestToggleShaded(const QModelIndex &index);
 
     /**
      * Request moving the task at the given index to the specified virtual
      * desktop.
      *
      * This is meant for tasks that have an associated window, and may be
      * a no-op when there is no window.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      * @param desktop A virtual desktop number.
      **/
     virtual void requestVirtualDesktop(const QModelIndex &index, qint32 desktop);
 
     /**
      * Request informing the window manager of new geometry for a visual
      * delegate for the task at the given index. The geometry should be in
      * screen coordinates.
      *
      * This base implementation does nothing.
      *
      * @param index An index in this tasks model.
      * @param geometry Visual delegate geometry in screen coordinates.
      * @param delegate The delegate. Implementations are on their own with
      * regard to extracting information from this, and should take care to
      * reject invalid objects.
      **/
     virtual void requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry,
         QObject *delegate = nullptr);
 };
 
 }
 
 #endif
diff --git a/libtaskmanager/launchertasksmodel.cpp b/libtaskmanager/launchertasksmodel.cpp
index 6f4d177c..cdb8640b 100644
--- a/libtaskmanager/launchertasksmodel.cpp
+++ b/libtaskmanager/launchertasksmodel.cpp
@@ -1,299 +1,310 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "launchertasksmodel.h"
 #include "tasktools.h"
 
 #include <KRun>
 #include <KService>
 #include <KStartupInfo>
 #include <KSycoca>
 
 #include <config-X11.h>
 
 #include <QIcon>
 #include <QTimer>
 #if HAVE_X11
 #include <QX11Info>
 #endif
 
 namespace TaskManager
 {
 
 class LauncherTasksModel::Private
 {
 public:
     Private(LauncherTasksModel *q);
     QList<QUrl> launchers;
     QHash<QUrl, AppData> appDataCache;
     QTimer sycocaChangeTimer;
 
     void init();
     AppData appData(const QUrl &url);
 
 private:
     LauncherTasksModel *q;
 };
 
 LauncherTasksModel::Private::Private(LauncherTasksModel *q)
     : q(q)
 {
 }
 
 void LauncherTasksModel::Private::init()
 {
     sycocaChangeTimer.setSingleShot(true);
     sycocaChangeTimer.setInterval(100);
 
     QObject::connect(&sycocaChangeTimer, &QTimer::timeout, q,
         [this]() {
             if (!launchers.count()) {
                 return;
             }
 
             appDataCache.clear();
 
             // Emit changes of all roles satisfied from app data cache.
             q->dataChanged(q->index(0, 0),  q->index(launchers.count() - 1, 0),
                 QVector<int>{Qt::DisplayRole, Qt::DecorationRole,
                 AbstractTasksModel::AppId, AbstractTasksModel::AppName,
                 AbstractTasksModel::GenericName, AbstractTasksModel::LauncherUrl});
         }
     );
 
     void (KSycoca::*myDatabaseChangeSignal)(const QStringList &) = &KSycoca::databaseChanged;
     QObject::connect(KSycoca::self(), myDatabaseChangeSignal, q,
         [this](const QStringList &changedResources) {
             if (changedResources.contains(QLatin1String("services"))
                 || changedResources.contains(QLatin1String("apps"))
                 || changedResources.contains(QLatin1String("xdgdata-apps"))) {
                 sycocaChangeTimer.start();
             }
         }
     );
 }
 
 AppData LauncherTasksModel::Private::appData(const QUrl &url)
 {
     if (!appDataCache.contains(url)) {
         const AppData &data = appDataFromUrl(url, QIcon::fromTheme(QLatin1String("unknown")));
         appDataCache.insert(url, data);
 
         return data;
     }
 
     return appDataCache.value(url);
 }
 
 LauncherTasksModel::LauncherTasksModel(QObject *parent)
     : AbstractTasksModel(parent)
     , d(new Private(this))
 {
     d->init();
 }
 
 LauncherTasksModel::~LauncherTasksModel()
 {
 }
 
 QVariant LauncherTasksModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() >= d->launchers.count()) {
         return QVariant();
     }
 
     const QUrl &url = d->launchers.at(index.row());
     const AppData &data = d->appData(url);
 
     if (role == Qt::DisplayRole) {
         return data.name;
     } else if (role == Qt::DecorationRole) {
         return data.icon;
     } else if (role == AppId) {
         return data.id;
     } else if (role == AppName) {
         return data.name;
     } else if (role == GenericName) {
         return data.genericName;
     } else if (role == LauncherUrl) {
         // Take resolved URL from cache.
         return data.url;
+    } else if (role == LauncherUrlWithoutIcon) {
+        // Take resolved URL from cache.
+        QUrl url = data.url;
+
+        if (url.hasQuery()) {
+            QUrlQuery query(url);
+            query.removeQueryItem(QLatin1String("iconData"));
+            url.setQuery(query);
+        }
+
+        return url;
     } else if (role == IsLauncher) {
         return true;
     } else if (role == IsOnAllVirtualDesktops) {
         return true;
     }
 
     return QVariant();
 }
 
 int LauncherTasksModel::rowCount(const QModelIndex &parent) const
 {
     return parent.isValid() ? 0 : d->launchers.count();
 }
 
 QStringList LauncherTasksModel::launcherList() const
 {
     return QUrl::toStringList(d->launchers);
 }
 
 void LauncherTasksModel::setLauncherList(const QStringList &launchers)
 {
     const QList<QUrl> &_urls = QUrl::fromStringList(launchers, QUrl::StrictMode);
     QList<QUrl> urls;
 
     // Reject invalid urls and duplicates.
     foreach(const QUrl &url, _urls) {
         if (url.isValid()) {
             bool dupe = false;
 
             foreach(const QUrl &addedUrl, urls) {
                 dupe = launcherUrlsMatch(url, addedUrl, IgnoreQueryItems);
             }
 
             if (!dupe) {
                 urls.append(url);
             }
         }
     }
 
     if (d->launchers != urls) {
         // Common case optimization: If the list changed but its size
         // did not (e.g. due to reordering by a user of this model),
         // just clear the caches and announce new data instead of
         // resetting.
         if (d->launchers.count() == urls.count()) {
             d->launchers.clear();
             d->appDataCache.clear();
 
             d->launchers = urls;
 
             emit dataChanged(index(0, 0), index(d->launchers.count() - 1, 0));
         } else {
             beginResetModel();
 
             d->launchers.clear();
             d->appDataCache.clear();
 
             d->launchers = urls;
 
             endResetModel();
         }
 
         emit launcherListChanged();
     }
 }
 
 bool LauncherTasksModel::requestAddLauncher(const QUrl &_url)
 {
     // isValid() for the passed-in URL might return true if it was
     // constructed in TolerantMode, but we want to reject invalid URLs.
     QUrl url(_url.toString(), QUrl::StrictMode);
 
     if (url.isEmpty() || !url.isValid()) {
         return false;
     }
 
     // Reject duplicates.
     foreach(const QUrl &launcher, d->launchers) {
         if (launcherUrlsMatch(url, launcher, IgnoreQueryItems)) {
             return false;
         }
     }
 
     const int count = d->launchers.count();
     beginInsertRows(QModelIndex(), count, count);
     d->launchers.append(url);
     endInsertRows();
 
     emit launcherListChanged();
 
     return true;
 }
 
 bool LauncherTasksModel::requestRemoveLauncher(const QUrl &url)
 {
     for (int i = 0; i < d->launchers.count(); ++i) {
         const QUrl &launcher = d->launchers.at(i);
 
         if (launcherUrlsMatch(url, launcher, IgnoreQueryItems)
             || launcherUrlsMatch(url, d->appData(launcher).url, IgnoreQueryItems)) {
             beginRemoveRows(QModelIndex(), i, i);
             d->launchers.removeAt(i);
             d->appDataCache.remove(launcher);
             endRemoveRows();
 
             emit launcherListChanged();
 
             return true;
         }
     }
 
     return false;
 }
 
 int LauncherTasksModel::launcherPosition(const QUrl &url) const
 {
     for (int i = 0; i < d->launchers.count(); ++i) {
         if (launcherUrlsMatch(url, d->launchers.at(i), IgnoreQueryItems)) {
             return i;
         }
     }
 
     return -1;
 }
 
 void LauncherTasksModel::requestActivate(const QModelIndex &index)
 {
     requestNewInstance(index);
 }
 
 void LauncherTasksModel::requestNewInstance(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this
         || index.row() < 0 || index.row() >= d->launchers.count()) {
         return;
     }
 
     const QUrl &url = d->launchers.at(index.row());
 
     quint32 timeStamp = 0;
 
 #if HAVE_X11
         if (QX11Info::isPlatformX11()) {
             timeStamp = QX11Info::appUserTime();
         }
 #endif
 
     if (url.scheme() == QLatin1String("preferred")) {
         KService::Ptr service = KService::serviceByStorageId(defaultApplication(url));
 
         if (!service) {
             return;
         }
 
         new KRun(QUrl::fromLocalFile(service->entryPath()), 0, false,
             KStartupInfo::createNewStartupIdForTimestamp(timeStamp));
     } else {
         new KRun(url, 0, false, KStartupInfo::createNewStartupIdForTimestamp(timeStamp));
     }
 }
 
 }
diff --git a/libtaskmanager/startuptasksmodel.cpp b/libtaskmanager/startuptasksmodel.cpp
index 1b5350d3..3fda2db5 100644
--- a/libtaskmanager/startuptasksmodel.cpp
+++ b/libtaskmanager/startuptasksmodel.cpp
@@ -1,278 +1,278 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "startuptasksmodel.h"
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KService>
 #include <KServiceTypeTrader>
 #include <KStartupInfo>
 
 #include <QIcon>
 #include <QTimer>
 #include <QUrl>
 
 namespace TaskManager
 {
 
 class StartupTasksModel::Private
 {
 public:
     Private(StartupTasksModel *q);
     KDirWatch* configWatcher = nullptr;
     KStartupInfo *startupInfo = nullptr;
     QVector<KStartupInfoId> startups;
     QHash<QByteArray, KStartupInfoData> startupData;
     QHash<QByteArray, QUrl> launcherUrls;
 
     void init();
     void loadConfig();
     QUrl launcherUrl(const KStartupInfoData &data);
 
 private:
     StartupTasksModel *q;
 };
 
 StartupTasksModel::Private::Private(StartupTasksModel *q)
     : q(q)
 {
 }
 
 void StartupTasksModel::Private::init()
 {
     configWatcher = new KDirWatch(q);
     configWatcher->addFile(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)
         + QLatin1String("/klaunchrc"));
 
     QObject::connect(configWatcher, &KDirWatch::dirty, [this] { loadConfig(); });
     QObject::connect(configWatcher, &KDirWatch::created, [this] { loadConfig(); });
     QObject::connect(configWatcher, &KDirWatch::deleted, [this] { loadConfig(); });
 
     loadConfig();
 }
 
 void StartupTasksModel::Private::loadConfig()
 {
     const KConfig _c("klaunchrc");
     KConfigGroup c(&_c, "FeedbackStyle");
 
     if (!c.readEntry("TaskbarButton", true)) {
         delete startupInfo;
         startupInfo = nullptr;
 
         q->beginResetModel();
         startups.clear();
         startupData.clear();
         q->endResetModel();
 
         return;
     }
 
     if (!startupInfo) {
         startupInfo = new KStartupInfo(KStartupInfo::CleanOnCantDetect, q);
 
         QObject::connect(startupInfo, &KStartupInfo::gotNewStartup, q,
             [this](const KStartupInfoId &id, const KStartupInfoData &data) {
                 if (startups.contains(id)) {
                     return;
                 }
 
                 const QString appId = data.applicationId();
                 const QString bin = data.bin();
 
                 foreach(const KStartupInfoData &known, startupData) {
                     // Reject if we already have a startup notification for this app.
                     if (known.applicationId() == appId && known.bin() == bin) {
                         return;
                     }
                 }
 
                 const int count = startups.count();
                 q->beginInsertRows(QModelIndex(), count, count);
                 startups.append(id);
                 startupData.insert(id.id(), data);
                 launcherUrls.insert(id.id(), launcherUrl(data));
                 q->endInsertRows();
             }
         );
 
         QObject::connect(startupInfo, &KStartupInfo::gotRemoveStartup, q,
             [this](const KStartupInfoId &id) {
                 // The order in which startups are cancelled and corresponding
                 // windows appear is not reliable. Add some grace time to make
                 // an overlap more likely, giving a proxy some time to arbitrate
                 // between the two.
                 QTimer::singleShot(500,
                     [this, id]() {
                         const int row = startups.indexOf(id);
 
                         if (row != -1) {
                             q->beginRemoveRows(QModelIndex(), row, row);
                             startups.removeAt(row);
                             startupData.remove(id.id());
                             launcherUrls.remove(id.id());
                             q->endRemoveRows();
                         }
                     }
                 );
             }
         );
 
         QObject::connect(startupInfo, &KStartupInfo::gotStartupChange, q,
             [this](const KStartupInfoId &id, const KStartupInfoData &data) {
                 const int row = startups.indexOf(id);
                 if (row != -1) {
                     startupData.insert(id.id(), data);
                     launcherUrls.insert(id.id(), launcherUrl(data));
                     QModelIndex idx = q->index(row);
                     emit q->dataChanged(idx, idx);
                 }
             }
         );
     }
 
     c = KConfigGroup(&_c, "TaskbarButtonSettings");
     startupInfo->setTimeout(c.readEntry("Timeout", 5));
 }
 
 QUrl StartupTasksModel::Private::launcherUrl(const KStartupInfoData &data)
 {
     QUrl launcherUrl;
     KService::List services;
 
     QString appId = data.applicationId();
 
     // Try to match via desktop filename ...
     if (!appId.isEmpty() && appId.endsWith(QLatin1String(".desktop"))) {
         if (appId.startsWith(QLatin1String("/"))) {
             launcherUrl = QUrl::fromLocalFile(appId);
             return launcherUrl;
         } else {
             if (appId.endsWith(QLatin1String(".desktop"))) {
                 appId = appId.mid(appId.length() - 8);
             }
 
             services = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
                 QStringLiteral("exist Exec and ('%1' =~ DesktopEntryName)").arg(appId));
         }
     }
 
     const QString wmClass = data.WMClass();
 
     // Try StartupWMClass.
     if (services.empty() && !wmClass.isEmpty()) {
         services = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
             QStringLiteral("exist Exec and ('%1' =~ StartupWMClass)").arg(wmClass));
     }
 
     const QString name = data.findName();
 
     // Try via name ...
     if (services.empty() && !name.isEmpty()) {
         services = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
             QStringLiteral("exist Exec and ('%1' =~ Name)").arg(name));
     }
 
     if (!services.empty()) {
         QString path = services.at(0)->entryPath();
 
         if (path.isEmpty()) {
             path = services.at(0)->exec();
         }
 
         if (!path.isEmpty()) {
             launcherUrl = QUrl::fromLocalFile(path);
         }
     }
 
     return launcherUrl;
 }
 
 StartupTasksModel::StartupTasksModel(QObject *parent)
     : AbstractTasksModel(parent)
     , d(new Private(this))
 {
     d->init();
 }
 
 StartupTasksModel::~StartupTasksModel()
 {
 }
 
 QVariant StartupTasksModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()  || index.row() >= d->startups.count()) {
         return QVariant();
     }
 
     const QByteArray &id = d->startups.at(index.row()).id();
 
     if (!d->startupData.contains(id)) {
         return QVariant();
     }
 
     const KStartupInfoData &data = d->startupData.value(id);
 
     if (role == Qt::DisplayRole) {
         return data.findName();
     } else if (role == Qt::DecorationRole) {
         return QIcon::fromTheme(data.findIcon(), QIcon::fromTheme(QLatin1String("unknown")));
     } else if (role == AppId) {
         QString idFromPath = QUrl::fromLocalFile(data.applicationId()).fileName();
 
         if (idFromPath.endsWith(QLatin1String(".desktop"))) {
             idFromPath = idFromPath.left(idFromPath.length() - 8);
         }
 
         return idFromPath;
     } else if (role == AppName) {
         return data.findName();
-    } else if (role == LauncherUrl) {
+    } else if (role == LauncherUrl || role == LauncherUrlWithoutIcon) {
         return d->launcherUrls.value(id);
     } else if (role == IsStartup) {
         return true;
     } else if (role == VirtualDesktop) {
         return data.desktop();
     } else if (role == IsOnAllVirtualDesktops) {
         return (data.desktop() == 0);
     } /* else if (role == Screen) {
         // You might be tempted to do this, but KStartupInfoData::screen()
         // is actually the X11 screen.
         return (data.screen() == 0);
     } */
 
     return QVariant();
 }
 
 int StartupTasksModel::rowCount(const QModelIndex &parent) const
 {
     return parent.isValid() ? 0 : d->startups.count();
 }
 
 void StartupTasksModel::requestNewInstance(const QModelIndex &index)
 {
     Q_UNUSED(index)
 
     // FIXME Implement.
 }
 
 }
diff --git a/libtaskmanager/tasksmodel.cpp b/libtaskmanager/tasksmodel.cpp
index 298a22a3..9d462dd6 100644
--- a/libtaskmanager/tasksmodel.cpp
+++ b/libtaskmanager/tasksmodel.cpp
@@ -1,1568 +1,1566 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "tasksmodel.h"
 #include "activityinfo.h"
 #include "concatenatetasksproxymodel.h"
 #include "flattentaskgroupsproxymodel.h"
 #include "taskfilterproxymodel.h"
 #include "taskgroupingproxymodel.h"
 #include "tasktools.h"
 
 #include <config-X11.h>
 
 #include "launchertasksmodel.h"
 #include "waylandtasksmodel.h"
 #include "startuptasksmodel.h"
 #if HAVE_X11
 #include "xwindowtasksmodel.h"
 #endif
 
 #include <KWindowSystem>
 
 #include <QGuiApplication>
 #include <QTimer>
 #include <QUrl>
 
 #if HAVE_X11
 #include <QX11Info>
 #endif
 
 #include <numeric>
 
 namespace TaskManager
 {
 
 class TasksModel::Private
 {
 public:
     Private(TasksModel *q);
     ~Private();
 
     static int instanceCount;
 
     static AbstractTasksModel* windowTasksModel;
     static StartupTasksModel* startupTasksModel;
     LauncherTasksModel* launcherTasksModel = nullptr;
     ConcatenateTasksProxyModel* concatProxyModel = nullptr;
     TaskFilterProxyModel* filterProxyModel = nullptr;
     TaskGroupingProxyModel* groupingProxyModel = nullptr;
     FlattenTaskGroupsProxyModel* flattenGroupsProxyModel = nullptr;
     AbstractTasksModelIface *abstractTasksSourceModel = nullptr;
 
     bool anyTaskDemandsAttention = false;
 
     int launcherCount = 0;
     int virtualDesktop = -1;
     int screen = -1;
     QString activity;
 
     SortMode sortMode = SortAlpha;
     bool separateLaunchers = true;
     bool launchInPlace = false;
     bool launchersEverSet = false;
     bool launcherSortingDirty = false;
     QList<int> sortedPreFilterRows;
     QVector<int> sortRowInsertQueue;
     QHash<QString, int> activityTaskCounts;
     static ActivityInfo* activityInfo;
     static int activityInfoUsers;
 
     bool groupInline = false;
     int groupingWindowTasksThreshold = -1;
 
     void initModels();
     void updateAnyTaskDemandsAttention();
     void updateManualSortMap();
     void consolidateManualSortMapForGroup(const QModelIndex &groupingProxyIndex);
     void updateGroupInline();
     QModelIndex preFilterIndex(const QModelIndex &sourceIndex) const;
     void updateActivityTaskCounts();
     void forceResort();
     bool lessThan(const QModelIndex &left, const QModelIndex &right,
         bool sortOnlyLaunchers = false) const;
 
 private:
     TasksModel *q;
 };
 
 class TasksModel::TasksModelLessThan
 {
 public:
     inline TasksModelLessThan(const QAbstractItemModel *s, TasksModel *p, bool sortOnlyLaunchers)
         : sourceModel(s), tasksModel(p), sortOnlyLaunchers(sortOnlyLaunchers) {}
 
     inline bool operator()(int r1, int r2) const
     {
         QModelIndex i1 = sourceModel->index(r1, 0);
         QModelIndex i2 = sourceModel->index(r2, 0);
         return tasksModel->d->lessThan(i1, i2, sortOnlyLaunchers);
     }
 
 private:
     const QAbstractItemModel *sourceModel;
     const TasksModel *tasksModel;
     bool sortOnlyLaunchers;
 };
 
 int TasksModel::Private::instanceCount = 0;
 AbstractTasksModel* TasksModel::Private::windowTasksModel = nullptr;
 StartupTasksModel* TasksModel::Private::startupTasksModel = nullptr;
 ActivityInfo* TasksModel::Private::activityInfo = nullptr;
 int TasksModel::Private::activityInfoUsers = 0;
 
 TasksModel::Private::Private(TasksModel *q)
     : q(q)
 {
     ++instanceCount;
 }
 
 TasksModel::Private::~Private()
 {
     --instanceCount;
 
     if (sortMode == SortActivity) {
         --activityInfoUsers;
     }
 
     if (!instanceCount) {
         delete windowTasksModel;
         windowTasksModel = nullptr;
         delete startupTasksModel;
         startupTasksModel = nullptr;
         delete activityInfo;
         activityInfo = nullptr;
     }
 }
 
 void TasksModel::Private::initModels()
 {
     // NOTE: Overview over the entire model chain assembled here:
     // {X11,Wayland}WindowTasksModel, StartupTasksModel, LauncherTasksModel
     //  -> concatProxyModel concatenates them into a single list.
     //   -> filterProxyModel filters by state (e.g. virtual desktop).
     //    -> groupingProxyModel groups by application (we go from flat list to tree).
     //     -> flattenGroupsProxyModel (optionally, if groupInline == true) flattens groups out.
     //      -> TasksModel collapses (top-level) items into task lifecycle abstraction; sorts.
 
     if (!windowTasksModel && QGuiApplication::platformName().startsWith(QLatin1String("wayland"))) {
         windowTasksModel = new WaylandTasksModel();
     }
 
 #if HAVE_X11
     if (!windowTasksModel && QX11Info::isPlatformX11()) {
         windowTasksModel = new XWindowTasksModel();
     }
 #endif
 
     QObject::connect(windowTasksModel, &QAbstractItemModel::rowsInserted, q,
         [this]() {
             if (sortMode == SortActivity) {
                 updateActivityTaskCounts();
             }
         }
     );
 
     QObject::connect(windowTasksModel, &QAbstractItemModel::rowsRemoved, q,
         [this]() {
             if (sortMode == SortActivity) {
                 updateActivityTaskCounts();
                 forceResort();
             }
         }
     );
 
     QObject::connect(windowTasksModel, &QAbstractItemModel::dataChanged, q,
         [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
             Q_UNUSED(topLeft)
             Q_UNUSED(bottomRight)
 
             if (sortMode == SortActivity && roles.contains(AbstractTasksModel::Activities)) {
                 updateActivityTaskCounts();
             }
         }
     );
 
     if (!startupTasksModel) {
         startupTasksModel = new StartupTasksModel();
     }
 
     launcherTasksModel = new LauncherTasksModel(q);
     QObject::connect(launcherTasksModel, &LauncherTasksModel::launcherListChanged,
         q, &TasksModel::launcherListChanged);
 
     concatProxyModel = new ConcatenateTasksProxyModel(q);
 
     concatProxyModel->addSourceModel(windowTasksModel);
     concatProxyModel->addSourceModel(startupTasksModel);
     concatProxyModel->addSourceModel(launcherTasksModel);
 
     // If we're in manual sort mode, we need to seed the sort map on pending row
     // insertions.
     QObject::connect(concatProxyModel, &QAbstractItemModel::rowsAboutToBeInserted, q,
         [this](const QModelIndex &parent, int start, int end) {
             Q_UNUSED(parent)
 
             if (sortMode != SortManual) {
                 return;
             }
 
             const int delta = (end - start) + 1;
             QMutableListIterator<int> it(sortedPreFilterRows);
 
             while (it.hasNext()) {
                 it.next();
 
                 if (it.value() >= start) {
                     it.setValue(it.value() + delta);
                 }
             }
 
             for (int i = start; i <= end; ++i) {
                 sortedPreFilterRows.append(i);
 
                 if (!separateLaunchers) {
                     sortRowInsertQueue.append(sortedPreFilterRows.count() - 1);
                 }
             }
         }
     );
 
     // If we're in manual sort mode, we need to update the sort map on row insertions.
     QObject::connect(concatProxyModel, &QAbstractItemModel::rowsInserted, q,
         [this](const QModelIndex &parent, int start, int end) {
             Q_UNUSED(parent)
             Q_UNUSED(start)
             Q_UNUSED(end)
 
             if (sortMode == SortManual) {
                 updateManualSortMap();
             }
         }
     );
 
     // If we're in manual sort mode, we need to update the sort map on row removals.
     QObject::connect(concatProxyModel, &QAbstractItemModel::rowsAboutToBeRemoved, q,
         [this](const QModelIndex &parent, int first, int last) {
             Q_UNUSED(parent)
 
             if (sortMode != SortManual) {
                 return;
             }
 
             for (int i = first; i <= last; ++i) {
                 sortedPreFilterRows.removeOne(i);
             }
 
             const int delta = (last - first) + 1;
             QMutableListIterator<int> it(sortedPreFilterRows);
 
             while (it.hasNext()) {
                 it.next();
 
                 if (it.value() > last) {
                     it.setValue(it.value() - delta);
                 }
             }
         }
     );
 
     filterProxyModel = new TaskFilterProxyModel(q);
     filterProxyModel->setSourceModel(concatProxyModel);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::virtualDesktopChanged,
         q, &TasksModel::virtualDesktopChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::screenChanged,
         q, &TasksModel::screenChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::activityChanged,
         q, &TasksModel::activityChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByVirtualDesktopChanged,
         q, &TasksModel::filterByVirtualDesktopChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByScreenChanged,
         q, &TasksModel::filterByScreenChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByActivityChanged,
         q, &TasksModel::filterByActivityChanged);
     QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterNotMinimizedChanged,
         q, &TasksModel::filterNotMinimizedChanged);
 
     groupingProxyModel = new TaskGroupingProxyModel(q);
     groupingProxyModel->setSourceModel(filterProxyModel);
     QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::groupModeChanged,
         q, &TasksModel::groupModeChanged);
     QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::blacklistedAppIdsChanged,
         q, &TasksModel::groupingAppIdBlacklistChanged);
     QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::blacklistedLauncherUrlsChanged,
         q, &TasksModel::groupingLauncherUrlBlacklistChanged);
 
     QObject::connect(groupingProxyModel, &QAbstractItemModel::rowsInserted, q,
         [this](const QModelIndex &parent, int first, int last) {
             if (parent.isValid()) {
                 if (sortMode == SortManual) {
                     consolidateManualSortMapForGroup(parent);
                 }
 
                 // Existence of a group means everything below this has already been done.
                 return;
             }
 
             for (int i = first; i <= last; ++i) {
                 const QModelIndex &sourceIndex = groupingProxyModel->index(i, 0);
                 const QString &appId = sourceIndex.data(AbstractTasksModel::AppId).toString();
 
                 if (sourceIndex.data(AbstractTasksModel::IsDemandingAttention).toBool()) {
                     updateAnyTaskDemandsAttention();
                 }
 
                 // When we get a window we have a startup for, cause the startup to be re-filtered.
                 if (sourceIndex.data(AbstractTasksModel::IsWindow).toBool()) {
                     const QString &appName = sourceIndex.data(AbstractTasksModel::AppName).toString();
 
                     for (int i = 0; i < startupTasksModel->rowCount(); ++i) {
                         QModelIndex startupIndex = startupTasksModel->index(i, 0);
 
                         if (appId == startupIndex.data(AbstractTasksModel::AppId).toString()
                             || appName == startupIndex.data(AbstractTasksModel::AppName).toString()) {
                             startupTasksModel->dataChanged(startupIndex, startupIndex);
                         }
                     }
                 }
 
                 // When we get a window or startup we have a launcher for, cause the launcher to be re-filtered.
                 if (sourceIndex.data(AbstractTasksModel::IsWindow).toBool()
                     || sourceIndex.data(AbstractTasksModel::IsStartup).toBool()) {
-                    const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl();
+                    const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
                     for (int i = 0; i < launcherTasksModel->rowCount(); ++i) {
                         QModelIndex launcherIndex = launcherTasksModel->index(i, 0);
                         const QString &launcherAppId = launcherIndex.data(AbstractTasksModel::AppId).toString();
 
-                        if ((!appId.isEmpty() && appId == launcherAppId)
-                            || (launcherUrl.isValid() && launcherUrlsMatch(launcherUrl,
-                            launcherIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems))) {
+                        if ((!appId.isEmpty() && appId == launcherAppId) || (launcherUrl.isValid()
+                            && launcherUrl == launcherIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl())) {
                             launcherTasksModel->dataChanged(launcherIndex, launcherIndex);
                         }
                     }
                 }
             }
          }
     );
 
     // When a window is removed, we have to trigger a re-filter of matching launchers.
     QObject::connect(groupingProxyModel, &QAbstractItemModel::rowsAboutToBeRemoved, q,
         [this](const QModelIndex &parent, int first, int last) {
             // We can ignore group members.
             if (parent.isValid()) {
                 return;
             }
 
             for (int i = first; i <= last; ++i) {
                 const QModelIndex &sourceIndex = groupingProxyModel->index(i, 0);
 
                 if (sourceIndex.data(AbstractTasksModel::IsDemandingAttention).toBool()) {
                     updateAnyTaskDemandsAttention();
                 }
 
                 if (!sourceIndex.data(AbstractTasksModel::IsWindow).toBool()) {
                     continue;
                 }
 
-                const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl();
+                const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
                 if (!launcherUrl.isEmpty() && launcherUrl.isValid()) {
                     const int pos = launcherTasksModel->launcherPosition(launcherUrl);
 
                     if (pos != -1) {
                         QModelIndex launcherIndex = launcherTasksModel->index(pos, 0);
 
                         QMetaObject::invokeMethod(launcherTasksModel, "dataChanged", Qt::QueuedConnection,
                             Q_ARG(QModelIndex, launcherIndex), Q_ARG(QModelIndex, launcherIndex));
                         QMetaObject::invokeMethod(q, "updateLauncherCount", Qt::QueuedConnection);
                     }
                 }
             }
         }
     );
 
     // Update anyTaskDemandsAttention on source data changes.
     QObject::connect(groupingProxyModel, &QAbstractItemModel::dataChanged, q,
         [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
             Q_UNUSED(bottomRight)
 
             // We can ignore group members.
             if (topLeft.parent().isValid()) {
                 return;
             }
 
             if (roles.isEmpty() || roles.contains(AbstractTasksModel::IsDemandingAttention)) {
                 updateAnyTaskDemandsAttention();
             }
         }
     );
 
     // Update anyTaskDemandsAttention on source model resets.
     QObject::connect(groupingProxyModel, &QAbstractItemModel::modelReset, q,
         [this]() { updateAnyTaskDemandsAttention(); }
     );
 
     abstractTasksSourceModel = groupingProxyModel;
     q->setSourceModel(groupingProxyModel);
 
     QObject::connect(q, &QAbstractItemModel::rowsInserted, q, &TasksModel::updateLauncherCount);
     QObject::connect(q, &QAbstractItemModel::rowsRemoved, q, &TasksModel::updateLauncherCount);
     QObject::connect(q, &QAbstractItemModel::modelReset, q, &TasksModel::updateLauncherCount);
 
     QObject::connect(q, &QAbstractItemModel::rowsInserted, q, &TasksModel::countChanged);
     QObject::connect(q, &QAbstractItemModel::rowsRemoved, q, &TasksModel::countChanged);
     QObject::connect(q, &QAbstractItemModel::modelReset, q, &TasksModel::countChanged);
 }
 
 void TasksModel::Private::updateAnyTaskDemandsAttention()
 {
     bool taskFound = false;
 
     for (int i = 0; i < groupingProxyModel->rowCount(); ++i) {
         if (groupingProxyModel->index(i, 0).data(AbstractTasksModel::IsDemandingAttention).toBool()) {
             taskFound = true;
             break;
         }
     }
 
     if (taskFound != anyTaskDemandsAttention) {
         anyTaskDemandsAttention = taskFound;
         q->anyTaskDemandsAttentionChanged();
     }
 }
 
 void TasksModel::Private::updateManualSortMap()
 {
     // Empty map; full sort.
     if (sortedPreFilterRows.isEmpty()) {
         sortedPreFilterRows.reserve(concatProxyModel->rowCount());
 
         for (int i = 0; i < concatProxyModel->rowCount(); ++i) {
             sortedPreFilterRows.append(i);
         }
 
         // Full sort.
         TasksModelLessThan lt(concatProxyModel, q, false);
         std::stable_sort(sortedPreFilterRows.begin(), sortedPreFilterRows.end(), lt);
 
         // Consolidate sort map entries for groups.
         if (q->groupMode() != GroupDisabled) {
             for (int i = 0; i < groupingProxyModel->rowCount(); ++i) {
                 const QModelIndex &groupingIndex = groupingProxyModel->index(i, 0);
 
                 if (groupingIndex.data(AbstractTasksModel::IsGroupParent).toBool()) {
                     consolidateManualSortMapForGroup(groupingIndex);
                 }
             }
         }
 
         return;
     }
 
     // Existing map; check whether launchers need sorting by launcher list position.
     if (separateLaunchers) {
         // Sort only launchers.
         TasksModelLessThan lt(concatProxyModel, q, true);
         std::stable_sort(sortedPreFilterRows.begin(), sortedPreFilterRows.end(), lt);
     // Otherwise process any entries in the insert queue and move them intelligently
     // in the sort map.
     } else {
          while (sortRowInsertQueue.count()) {
              const int row = sortRowInsertQueue.takeFirst();
              const QModelIndex &idx = concatProxyModel->index(sortedPreFilterRows.at(row), 0);
 
              bool moved = false;
 
              // Try to move the task up to its right-most app sibling, unless this
              // is us sorting in a launcher list for the first time.
              if (launchersEverSet && !idx.data(AbstractTasksModel::IsLauncher).toBool()) {
                  for (int i = (row - 1); i >= 0; --i) {
                      const QModelIndex &concatProxyIndex = concatProxyModel->index(sortedPreFilterRows.at(i), 0);
 
                      if (appsMatch(concatProxyIndex, idx)) {
                          sortedPreFilterRows.move(row, i + 1);
                          moved = true;
 
                          break;
                      }
                  }
              }
 
              int insertPos = 0;
 
              // If unsuccessful or skipped, and the new task is a launcher, put after
              // the rightmost launcher or launcher-backed task in the map, or failing
              // that at the start of the map.
              if (!moved && idx.data(AbstractTasksModel::IsLauncher).toBool()) {
                  for (int i = 0; i < row; ++i) {
                      const QModelIndex &concatProxyIndex = concatProxyModel->index(sortedPreFilterRows.at(i), 0);
 
                      if (concatProxyIndex.data(AbstractTasksModel::IsLauncher).toBool()
-                        || launcherTasksModel->launcherPosition(concatProxyIndex.data(AbstractTasksModel::LauncherUrl).toUrl()) != -1) {
+                        || launcherTasksModel->launcherPosition(concatProxyIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl()) != -1) {
                         insertPos = i + 1;
                      } else {
                         break;
                      }
                  }
 
                  sortedPreFilterRows.move(row, insertPos);
                  moved = true;
              }
 
              // If we sorted in a launcher and it's the first time we're sorting in a
              // launcher list, move existing windows to the launcher position now.
              if (moved && !launchersEverSet) {
                  for (int i = (sortedPreFilterRows.count() - 1); i >= 0; --i) {
                      const QModelIndex &concatProxyIndex = concatProxyModel->index(sortedPreFilterRows.at(i), 0);
 
                      if (!concatProxyIndex.data(AbstractTasksModel::IsLauncher).toBool()
-                         && launcherUrlsMatch(idx.data(AbstractTasksModel::LauncherUrl).toUrl(),
-                         concatProxyIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems)) {
+                         && idx.data(AbstractTasksModel::LauncherUrlWithoutIcon) == concatProxyIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon)) {
                          sortedPreFilterRows.move(i, insertPos);
 
                          if (insertPos > i) {
                              --insertPos;
                          }
                      }
                  }
              }
          }
      }
  }
 
 void TasksModel::Private::consolidateManualSortMapForGroup(const QModelIndex &groupingProxyIndex)
 {
     // Consolidates sort map entries for a group's items to be contiguous
     // after the group's first item and the same order as in groupingProxyModel.
 
     const int childCount = groupingProxyModel->rowCount(groupingProxyIndex);
 
     if (!childCount) {
         return;
     }
 
     const QModelIndex &leader = groupingProxyIndex.child(0, 0);
     const QModelIndex &preFilterLeader = filterProxyModel->mapToSource(groupingProxyModel->mapToSource(leader));
 
     // We're moving the trailing children to the sort map position of
     // the first child, so we're skipping the first child.
     for (int i = 1; i < childCount; ++i) {
         const QModelIndex &child = groupingProxyIndex.child(i, 0);
         const QModelIndex &preFilterChild = filterProxyModel->mapToSource(groupingProxyModel->mapToSource(child));
         const int leaderPos = sortedPreFilterRows.indexOf(preFilterLeader.row());
         const int childPos = sortedPreFilterRows.indexOf(preFilterChild.row());
         const int insertPos = (leaderPos + i) + ((leaderPos + i) > childPos ? -1 : 0);
         sortedPreFilterRows.move(childPos, insertPos);
     }
 }
 
 void TasksModel::Private::updateGroupInline()
 {
     if (q->groupMode() != GroupDisabled && groupInline) {
         if (flattenGroupsProxyModel) {
             return;
         }
 
         // Exempting tasks which demand attention from grouping is not
         // necessary when all group children are shown inline anyway
         // and would interfere with our sort-tasks-together goals.
         groupingProxyModel->setGroupDemandingAttention(true);
 
         // Likewise, ignore the window tasks threshold when making
         // grouping decisions.
         groupingProxyModel->setWindowTasksThreshold(-1);
 
         flattenGroupsProxyModel = new FlattenTaskGroupsProxyModel(q);
         flattenGroupsProxyModel->setSourceModel(groupingProxyModel);
 
         abstractTasksSourceModel = flattenGroupsProxyModel;
         q->setSourceModel(flattenGroupsProxyModel);
 
         if (sortMode == SortManual) {
             forceResort();
         }
     } else {
         if (!flattenGroupsProxyModel) {
             return;
         }
 
         groupingProxyModel->setGroupDemandingAttention(false);
         groupingProxyModel->setWindowTasksThreshold(groupingWindowTasksThreshold);
 
         abstractTasksSourceModel = groupingProxyModel;
         q->setSourceModel(groupingProxyModel);
 
         delete flattenGroupsProxyModel;
         flattenGroupsProxyModel = nullptr;
 
         if (sortMode == SortManual) {
             forceResort();
         }
     }
 }
 
 QModelIndex TasksModel::Private::preFilterIndex(const QModelIndex &sourceIndex) const {
     // Only in inline grouping mode, we have an additional proxy layer.
     if (flattenGroupsProxyModel) {
         return filterProxyModel->mapToSource(groupingProxyModel->mapToSource(flattenGroupsProxyModel->mapToSource(sourceIndex)));
     } else {
         return filterProxyModel->mapToSource(groupingProxyModel->mapToSource(sourceIndex));
     }
 }
 
 void TasksModel::Private::updateActivityTaskCounts()
 {
     // Collects the number of window tasks on each activity.
 
     activityTaskCounts.clear();
 
     if (!windowTasksModel || !activityInfo) {
         return;
     }
 
     foreach(const QString &activity, activityInfo->runningActivities()) {
         activityTaskCounts.insert(activity, 0);
     }
 
     for (int i = 0; i < windowTasksModel->rowCount(); ++i) {
         const QModelIndex &windowIndex = windowTasksModel->index(i, 0);
         const QStringList &activities = windowIndex.data(AbstractTasksModel::Activities).toStringList();
 
         if (activities.isEmpty()) {
             QMutableHashIterator<QString, int> i(activityTaskCounts);
 
             while (i.hasNext()) {
                 i.next();
                 i.setValue(i.value() + 1);
             }
         } else {
             foreach(const QString &activity, activities) {
                 ++activityTaskCounts[activity];
             }
         }
     }
 }
 
 void TasksModel::Private::forceResort()
 {
     // HACK: This causes QSortFilterProxyModel to run all rows through
     // our lessThan() implementation again.
     q->setDynamicSortFilter(false);
     q->setDynamicSortFilter(true);
 }
 
 bool TasksModel::Private::lessThan(const QModelIndex &left, const QModelIndex &right, bool sortOnlyLaunchers) const
 {
     // Launcher tasks go first.
     // When launchInPlace is enabled, startup and window tasks are sorted
     // as the launchers they replace (see also move()).
 
     if (separateLaunchers) {
         if (left.data(AbstractTasksModel::IsLauncher).toBool() && right.data(AbstractTasksModel::IsLauncher).toBool()) {
             return (left.row() < right.row());
         } else if (left.data(AbstractTasksModel::IsLauncher).toBool() && !right.data(AbstractTasksModel::IsLauncher).toBool()) {
             if (launchInPlace) {
                 const int rightPos = q->launcherPosition(right.data(AbstractTasksModel::LauncherUrl).toUrl());
 
                 if (rightPos != -1) {
                     return (left.row() < rightPos);
                 }
             }
 
             return true;
         } else if (!left.data(AbstractTasksModel::IsLauncher).toBool() && right.data(AbstractTasksModel::IsLauncher).toBool()) {
             if (launchInPlace) {
                 const int leftPos = q->launcherPosition(left.data(AbstractTasksModel::LauncherUrl).toUrl());
 
                 if (leftPos != -1) {
                     return (leftPos < right.row());
                 }
             }
 
             return false;
         } else if (launchInPlace) {
             const int leftPos = q->launcherPosition(left.data(AbstractTasksModel::LauncherUrl).toUrl());
             const int rightPos = q->launcherPosition(right.data(AbstractTasksModel::LauncherUrl).toUrl());
 
             if (leftPos != -1 && rightPos != -1) {
                 return (leftPos < rightPos);
             } else if (leftPos != -1 && rightPos == -1) {
                 return true;
             } else if (leftPos == -1 && rightPos != -1) {
                 return false;
             }
         }
     }
 
     // If told to stop after launchers we fall through to the existing map if it exists.
     if (sortOnlyLaunchers && !sortedPreFilterRows.isEmpty()) {
         return (sortedPreFilterRows.indexOf(left.row()) < sortedPreFilterRows.indexOf(right.row()));
     }
 
     // Sort other cases by sort mode.
     switch (sortMode) {
         case SortVirtualDesktop: {
             const QVariant &leftDesktopVariant = left.data(AbstractTasksModel::VirtualDesktop);
             bool leftOk = false;
             const int leftDesktop = leftDesktopVariant.toInt(&leftOk);
 
             const QVariant &rightDesktopVariant = right.data(AbstractTasksModel::VirtualDesktop);
             bool rightOk = false;
             const int rightDesktop = rightDesktopVariant.toInt(&rightOk);
 
             if (leftOk && rightOk && (leftDesktop != rightDesktop)) {
                 return (leftDesktop < rightDesktop);
             } else if (leftOk && !rightOk) {
                 return false;
             } else if (!leftOk && rightOk) {
                 return true;
             }
         }
         case SortActivity: {
             // updateActivityTaskCounts() counts the number of window tasks on each
             // activity. This will sort tasks by comparing a cumulative score made
             // up of the task counts for each acvtivity a task is assigned to, and
             // otherwise fall through to alphabetical sorting.
             int leftScore = -1;
             int rightScore = -1;
 
             const QStringList &leftActivities = left.data(AbstractTasksModel::Activities).toStringList();
 
             if (!leftActivities.isEmpty()) {
                 foreach(const QString& activity, leftActivities) {
                     leftScore += activityTaskCounts[activity];
                 }
             }
 
             const QStringList &rightActivities = right.data(AbstractTasksModel::Activities).toStringList();
 
             if (!rightActivities.isEmpty()) {
                 foreach(const QString& activity, rightActivities) {
                     rightScore += activityTaskCounts[activity];
                 }
             }
 
             if (leftScore == -1 || rightScore == -1) {
                 const QList<int> &counts = activityTaskCounts.values();
                 const int sumScore = std::accumulate(counts.begin(), counts.end(), 0);
 
                 if (leftScore == -1) {
                     leftScore = sumScore;
                 }
 
                 if (rightScore == -1) {
                     rightScore = sumScore;
                 }
             }
 
             if (leftScore != rightScore) {
                 return (leftScore > rightScore);
             }
         }
         // Fall through to source order if sorting is disabled or manual, or alphabetical by app name otherwise.
         default: {
             if (sortMode == SortDisabled) {
                 return (left.row() < right.row());
             } else {
                 const QString &leftSortString = left.data(AbstractTasksModel::AppName).toString()
                     + left.data(Qt::DisplayRole).toString();
 
                 const QString &rightSortString = right.data(AbstractTasksModel::AppName).toString()
                     + right.data(Qt::DisplayRole).toString();
 
                 return (leftSortString.localeAwareCompare(rightSortString) < 0);
             }
         }
     }
 }
 
 TasksModel::TasksModel(QObject *parent)
     : QSortFilterProxyModel(parent)
     , d(new Private(this))
 {
     d->initModels();
 
     // Start sorting.
     sort(0);
 }
 
 TasksModel::~TasksModel()
 {
 }
 
 QHash<int, QByteArray> TasksModel::roleNames() const
 {
     if (d->windowTasksModel) {
         return d->windowTasksModel->roleNames();
     }
 
     return QHash<int, QByteArray>();
 }
 
 int TasksModel::rowCount(const QModelIndex &parent) const
 {
     return QSortFilterProxyModel::rowCount(parent);
 }
 
 void TasksModel::updateLauncherCount()
 {
     QList<QUrl> launchers = QUrl::fromStringList(d->launcherTasksModel->launcherList());
 
     for (int i = 0; i < d->filterProxyModel->rowCount(); ++i) {
         const QModelIndex &filterIndex = d->filterProxyModel->index(i, 0);
 
         if (!filterIndex.data(AbstractTasksModel::IsLauncher).toBool()) {
             // TODO: It would be much faster if we didn't ask for a URL with serialized PNG
             // data in it, just to discard it a few lines below.
-            const QUrl &launcherUrl = filterIndex.data(AbstractTasksModel::LauncherUrl).toUrl();
+            const QUrl &launcherUrl = filterIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
             QMutableListIterator<QUrl> it(launchers);
 
             while(it.hasNext()) {
                 it.next();
 
-                if (launcherUrlsMatch(launcherUrl, it.value(), IgnoreQueryItems)) {
+                // RemoveQuery to strip possible fallback icon from stored launcher.
+                if (launcherUrl == it.value().adjusted(QUrl::RemoveQuery)) {
                     it.remove();
                 }
             }
         }
     }
 
     if (d->launcherCount != launchers.count()) {
         d->launcherCount = launchers.count();
         emit launcherCountChanged();
     }
 }
 
 int TasksModel::launcherCount() const
 {
     return d->launcherCount;
 }
 
 bool TasksModel::anyTaskDemandsAttention() const
 {
     return d->anyTaskDemandsAttention;
 }
 
 int TasksModel::virtualDesktop() const
 {
     return d->filterProxyModel->virtualDesktop();
 }
 
 void TasksModel::setVirtualDesktop(int virtualDesktop)
 {
     d->filterProxyModel->setVirtualDesktop(virtualDesktop);
 }
 
 int TasksModel::screen() const
 {
     return d->filterProxyModel->screen();
 }
 
 void TasksModel::setScreen(int screen)
 {
     d->filterProxyModel->setScreen(screen);
 }
 
 QString TasksModel::activity() const
 {
     return d->filterProxyModel->activity();
 }
 
 void TasksModel::setActivity(const QString &activity)
 {
     d->filterProxyModel->setActivity(activity);
 }
 
 bool TasksModel::filterByVirtualDesktop() const
 {
     return d->filterProxyModel->filterByVirtualDesktop();
 }
 
 void TasksModel::setFilterByVirtualDesktop(bool filter)
 {
     d->filterProxyModel->setFilterByVirtualDesktop(filter);
 }
 
 bool TasksModel::filterByScreen() const
 {
     return d->filterProxyModel->filterByScreen();
 }
 
 void TasksModel::setFilterByScreen(bool filter)
 {
     d->filterProxyModel->setFilterByScreen(filter);
 }
 
 bool TasksModel::filterByActivity() const
 {
     return d->filterProxyModel->filterByActivity();
 }
 
 void TasksModel::setFilterByActivity(bool filter)
 {
     d->filterProxyModel->setFilterByActivity(filter);
 }
 
 bool TasksModel::filterNotMinimized() const
 {
     return d->filterProxyModel->filterNotMinimized();
 }
 
 void TasksModel::setFilterNotMinimized(bool filter)
 {
     d->filterProxyModel->setFilterNotMinimized(filter);
 }
 
 TasksModel::SortMode TasksModel::sortMode() const
 {
     return d->sortMode;
 }
 
 void TasksModel::setSortMode(SortMode mode)
 {
     if (d->sortMode != mode) {
         if (mode == SortManual) {
             d->updateManualSortMap();
         } else if (d->sortMode == SortManual) {
             d->sortedPreFilterRows.clear();
         }
 
         if (mode == SortActivity) {
             if (!d->activityInfo) {
                 d->activityInfo = new ActivityInfo();
             }
 
             ++d->activityInfoUsers;
 
             d->updateActivityTaskCounts();
             setSortRole(AbstractTasksModel::Activities);
         } else if (d->sortMode == SortActivity) {
             --d->activityInfoUsers;
 
             if (!d->activityInfoUsers) {
                 delete d->activityInfo;
                 d->activityInfo = nullptr;
             }
 
             d->activityTaskCounts.clear();
             setSortRole(Qt::DisplayRole);
         }
 
         d->sortMode = mode;
 
         d->forceResort();
 
         emit sortModeChanged();
     }
 }
 
 bool TasksModel::separateLaunchers() const
 {
     return d->separateLaunchers;
 }
 
 void TasksModel::setSeparateLaunchers(bool separate)
 {
     if (d->separateLaunchers != separate) {
         d->separateLaunchers = separate;
 
         d->updateManualSortMap();
         d->forceResort();
 
         emit separateLaunchersChanged();
     }
 }
 
 bool TasksModel::launchInPlace() const
 {
     return d->launchInPlace;
 }
 
 void TasksModel::setLaunchInPlace(bool launchInPlace)
 {
     if (d->launchInPlace != launchInPlace) {
         d->launchInPlace = launchInPlace;
 
         d->forceResort();
 
         emit launchInPlaceChanged();
     }
 }
 
 TasksModel::GroupMode TasksModel::groupMode() const
 {
     if (!d->groupingProxyModel) {
         return GroupDisabled;
     }
 
     return d->groupingProxyModel->groupMode();
 }
 
 void TasksModel::setGroupMode(GroupMode mode)
 {
     if (d->groupingProxyModel) {
         if (mode == GroupDisabled && d->flattenGroupsProxyModel) {
             d->flattenGroupsProxyModel->setSourceModel(nullptr);
         }
 
         d->groupingProxyModel->setGroupMode(mode);
         d->updateGroupInline();
     }
 }
 
 bool TasksModel::groupInline() const
 {
     return d->groupInline;
 }
 
 void TasksModel::setGroupInline(bool groupInline)
 {
     if (d->groupInline != groupInline) {
         d->groupInline = groupInline;
 
         d->updateGroupInline();
 
         emit groupInlineChanged();
     }
 }
 
 int TasksModel::groupingWindowTasksThreshold() const
 {
     return d->groupingWindowTasksThreshold;
 }
 
 void TasksModel::setGroupingWindowTasksThreshold(int threshold)
 {
     if (d->groupingWindowTasksThreshold != threshold) {
         d->groupingWindowTasksThreshold = threshold;
 
         if (!d->groupInline && d->groupingProxyModel) {
             d->groupingProxyModel->setWindowTasksThreshold(threshold);
         }
 
         emit groupingWindowTasksThresholdChanged();
     }
 }
 
 QStringList TasksModel::groupingAppIdBlacklist() const
 {
     if (!d->groupingProxyModel) {
         return QStringList();
     }
 
     return d->groupingProxyModel->blacklistedAppIds();
 }
 
 void TasksModel::setGroupingAppIdBlacklist(const QStringList &list)
 {
     if (d->groupingProxyModel) {
         d->groupingProxyModel->setBlacklistedAppIds(list);
     }
 }
 
 QStringList TasksModel::groupingLauncherUrlBlacklist() const
 {
     if (!d->groupingProxyModel) {
         return QStringList();
     }
 
     return d->groupingProxyModel->blacklistedLauncherUrls();
 }
 
 void TasksModel::setGroupingLauncherUrlBlacklist(const QStringList &list)
 {
     if (d->groupingProxyModel) {
         d->groupingProxyModel->setBlacklistedLauncherUrls(list);
     }
 }
 
 QStringList TasksModel::launcherList() const
 {
     if (d->launcherTasksModel) {
         return d->launcherTasksModel->launcherList();
     }
 
     return QStringList();
 }
 
 void TasksModel::setLauncherList(const QStringList &launchers)
 {
     if (d->launcherTasksModel) {
         d->launcherTasksModel->setLauncherList(launchers);
         d->launchersEverSet = true;
     }
 }
 
 bool TasksModel::requestAddLauncher(const QUrl &url)
 {
     if (d->launcherTasksModel) {
         bool added = d->launcherTasksModel->requestAddLauncher(url);
 
         // If using manual sorting and launch-in-place sorting, we need
         // to trigger a sort map update to move any window tasks to their
         // launcher position now.
         if (added && d->sortMode == SortManual && (d->launchInPlace || !d->separateLaunchers)) {
             d->updateManualSortMap();
             d->forceResort();
         }
 
         return added;
     }
 
     return false;
 }
 
 bool TasksModel::requestRemoveLauncher(const QUrl &url)
 {
     if (d->launcherTasksModel) {
         return d->launcherTasksModel->requestRemoveLauncher(url);
     }
 
     return false;
 }
 
 int TasksModel::launcherPosition(const QUrl &url) const
 {
     if (d->launcherTasksModel) {
         return d->launcherTasksModel->launcherPosition(url);
     }
 
     return -1;
 }
 
 void TasksModel::requestActivate(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestActivate(mapToSource(index));
     }
 }
 
 void TasksModel::requestNewInstance(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestNewInstance(mapToSource(index));
     }
 }
 
 void TasksModel::requestClose(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestClose(mapToSource(index));
     }
 }
 
 void TasksModel::requestMove(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestMove(mapToSource(index));
     }
 }
 
 void TasksModel::requestResize(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestResize(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleMinimized(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleMinimized(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleMaximized(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleMaximized(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleKeepAbove(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleKeepAbove(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleKeepBelow(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleKeepBelow(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleFullScreen(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleFullScreen(mapToSource(index));
     }
 }
 
 void TasksModel::requestToggleShaded(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestToggleShaded(mapToSource(index));
     }
 }
 
 void TasksModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestVirtualDesktop(mapToSource(index), desktop);
     }
 }
 
 void TasksModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate)
 {
     if (index.isValid() && index.model() == this) {
         d->abstractTasksSourceModel->requestPublishDelegateGeometry(mapToSource(index), geometry, delegate);
     }
 }
 
 void TasksModel::requestToggleGrouping(const QModelIndex &index)
 {
     if (index.isValid() && index.model() == this) {
         const QModelIndex &target = (d->flattenGroupsProxyModel
             ? d->flattenGroupsProxyModel->mapToSource(mapToSource(index)) : mapToSource(index));
         d->groupingProxyModel->requestToggleGrouping(target);
     }
 }
 
 bool TasksModel::move(int row, int newPos)
 {
     if (d->sortMode != SortManual || row == newPos || newPos < 0 || newPos >= rowCount()) {
         return false;
     }
 
     const QModelIndex &idx = index(row, 0);
     bool isLauncherMove = false;
 
     // Figure out if we're moving a launcher so we can run barrier checks.
     if (idx.isValid()) {
         if (idx.data(AbstractTasksModel::IsLauncher).toBool()) {
             isLauncherMove = true;
         // When using launch-in-place sorting, launcher-backed window tasks act as launchers.
         } else if ((d->launchInPlace || !d->separateLaunchers)
             && idx.data(AbstractTasksModel::IsWindow).toBool()) {
             const QUrl &launcherUrl = idx.data(AbstractTasksModel::LauncherUrl).toUrl();
             const int launcherPos = launcherPosition(launcherUrl);
 
             if (launcherPos != -1) {
                 isLauncherMove = true;
             }
         }
     } else {
         return false;
     }
 
     if (d->separateLaunchers) {
         const int firstTask = (d->launchInPlace ? d->launcherTasksModel->rowCount() : launcherCount());
 
         // Don't allow launchers to be moved past the last launcher.
         if (isLauncherMove && newPos >= firstTask) {
             return false;
         }
 
         // Don't allow tasks to be moved into the launchers.
         if (!isLauncherMove && newPos < firstTask) {
             return false;
         }
     }
 
     // Treat flattened-out groups as single items.
     if (d->flattenGroupsProxyModel) {
         QModelIndex groupingRowIndex = d->flattenGroupsProxyModel->mapToSource(mapToSource(index(row, 0)));
         const QModelIndex &groupingRowIndexParent = groupingRowIndex.parent();
         QModelIndex groupingNewPosIndex = d->flattenGroupsProxyModel->mapToSource(mapToSource(index(newPos, 0)));
         const QModelIndex &groupingNewPosIndexParent = groupingNewPosIndex.parent();
 
         // Disallow moves within a flattened-out group (TODO: for now, anyway).
         if (groupingRowIndexParent.isValid()
             && (groupingRowIndexParent == groupingNewPosIndex
             || groupingRowIndexParent == groupingNewPosIndexParent)) {
             return false;
         }
 
         int offset = 0;
         int extraChildCount = 0;
 
         if (groupingRowIndexParent.isValid()) {
             offset = groupingRowIndex.row();
             extraChildCount = d->groupingProxyModel->rowCount(groupingRowIndexParent) - 1;
             groupingRowIndex = groupingRowIndexParent;
         }
 
         if (groupingNewPosIndexParent.isValid()) {
             int extra = d->groupingProxyModel->rowCount(groupingNewPosIndexParent) - 1;
 
             if (newPos > row) {
                 newPos += extra;
                 newPos -= groupingNewPosIndex.row();
                 groupingNewPosIndex = groupingNewPosIndexParent.child(extra, 0);
             } else {
                 newPos -= groupingNewPosIndex.row();
                 groupingNewPosIndex = groupingNewPosIndexParent;
             }
         }
 
         beginMoveRows(QModelIndex(), (row - offset), (row - offset) + extraChildCount,
             QModelIndex(), (newPos > row) ? newPos + 1 : newPos);
 
         row = d->sortedPreFilterRows.indexOf(d->filterProxyModel->mapToSource(d->groupingProxyModel->mapToSource(groupingRowIndex)).row());
         newPos = d->sortedPreFilterRows.indexOf(d->filterProxyModel->mapToSource(d->groupingProxyModel->mapToSource(groupingNewPosIndex)).row());
 
         // Update sort mappings.
         d->sortedPreFilterRows.move(row, newPos);
 
         if (groupingRowIndexParent.isValid()) {
             d->consolidateManualSortMapForGroup(groupingRowIndexParent);
         }
 
         endMoveRows();
     } else {
         beginMoveRows(QModelIndex(), row, row, QModelIndex(), (newPos > row) ? newPos + 1 : newPos);
 
         // Translate to sort map indices.
         const QModelIndex &groupingRowIndex = mapToSource(index(row, 0));
         const QModelIndex &preFilterRowIndex = d->preFilterIndex(groupingRowIndex);
         row = d->sortedPreFilterRows.indexOf(preFilterRowIndex.row());
         newPos = d->sortedPreFilterRows.indexOf(d->preFilterIndex(mapToSource(index(newPos, 0))).row());
 
         // Update sort mapping.
         d->sortedPreFilterRows.move(row, newPos);
 
         // If we moved a group parent, consolidate sort map for children.
         if (groupMode() != GroupDisabled && d->groupingProxyModel->rowCount(groupingRowIndex)) {
             d->consolidateManualSortMapForGroup(groupingRowIndex);
         }
 
         endMoveRows();
     }
 
     // Resort.
     d->forceResort();
 
     if (!d->separateLaunchers && isLauncherMove) {
         const QModelIndex &idx = d->concatProxyModel->index(d->sortedPreFilterRows.at(newPos), 0);
-        const QUrl &launcherUrl = idx.data(AbstractTasksModel::LauncherUrl).toUrl();
+        const QUrl &launcherUrl = idx.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
         // Move launcher for launcher-backed task along with task if launchers
         // are not being kept separate.
         // We don't need to resort again because the launcher is implictly hidden
         // at this time.
         if (!idx.data(AbstractTasksModel::IsLauncher).toBool()) {
             const int launcherPos = d->launcherTasksModel->launcherPosition(launcherUrl);
             const QModelIndex &launcherIndex = d->launcherTasksModel->index(launcherPos, 0);
             const int sortIndex = d->sortedPreFilterRows.indexOf(d->concatProxyModel->mapFromSource(launcherIndex).row());
             d->sortedPreFilterRows.move(sortIndex, newPos);
         // Otherwise move matching windows to after the launcher task (they are
         // currently hidden but might be on another virtual desktop).
         } else {
             for (int i = (d->sortedPreFilterRows.count() - 1); i >= 0; --i) {
                 const QModelIndex &concatProxyIndex = d->concatProxyModel->index(d->sortedPreFilterRows.at(i), 0);
 
-                if (launcherUrlsMatch(launcherUrl,
-                    concatProxyIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems)) {
+                if (launcherUrl == concatProxyIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl()) {
                     d->sortedPreFilterRows.move(i, newPos);
 
                     if (newPos > i) {
                         --newPos;
                     }
                 }
             }
         }
     }
 
     // Setup for syncLaunchers().
     d->launcherSortingDirty = isLauncherMove;
 
     return true;
 }
 
 void TasksModel::syncLaunchers()
 {
     // Writes the launcher order exposed through the model back to the launcher
     // tasks model, committing any move() operations to persistent state.
 
     if (!d->launcherTasksModel || !d->launcherSortingDirty) {
         return;
     }
 
     QMap<int, QUrl> sortedLaunchers;
 
     foreach(const QUrl &launcherUrl, launcherList()) {
         int row = -1;
 
         for (int i = 0; i < rowCount(); ++i) {
-            const QUrl &rowLauncherUrl = index(i, 0).data(AbstractTasksModel::LauncherUrl).toUrl();
+            const QUrl &rowLauncherUrl = index(i, 0).data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
-            if (launcherUrlsMatch(launcherUrl, rowLauncherUrl, IgnoreQueryItems)) {
+            // RemoveQuery to strip possible fallback icon from stored launcher.
+            if (launcherUrl.adjusted(QUrl::RemoveQuery) == rowLauncherUrl) {
                 row = i;
                 break;
             }
         }
 
         if (row != -1) {
             sortedLaunchers.insert(row, launcherUrl);
         }
     }
 
     // Prep sort map for source model data changes.
     if (d->sortMode == SortManual) {
         QVector<int> sortMapIndices;
         QVector<int> preFilterRows;
 
         for (int i = 0; i < d->launcherTasksModel->rowCount(); ++i) {
             const QModelIndex &launcherIndex = d->launcherTasksModel->index(i, 0);
             const QModelIndex &concatIndex = d->concatProxyModel->mapFromSource(launcherIndex);
             sortMapIndices << d->sortedPreFilterRows.indexOf(concatIndex.row());
             preFilterRows << concatIndex.row();
         }
 
         // We're going to write back launcher model entries in the sort
         // map in concat model order, matching the reordered launcher list
         // we're about to pass down.
         std::sort(sortMapIndices.begin(), sortMapIndices.end());
 
         for (int i = 0; i < sortMapIndices.count(); ++i) {
             d->sortedPreFilterRows.replace(sortMapIndices.at(i), preFilterRows.at(i));
         }
     }
 
     setLauncherList(QUrl::toStringList(sortedLaunchers.values()));
     d->launcherSortingDirty = false;
 }
 
 QModelIndex TasksModel::activeTask() const
 {
     for (int i = 0; i < rowCount(); ++i) {
         const QModelIndex &idx = index(i, 0);
 
         if (idx.data(AbstractTasksModel::IsActive).toBool()) {
             if (groupMode() != GroupDisabled && rowCount(idx)) {
                 for (int j = 0; j < rowCount(idx); ++j) {
                     const QModelIndex &child = idx.child(j, 0);
 
                     if (child.data(AbstractTasksModel::IsActive).toBool()) {
                         return child;
                     }
                 }
             } else {
                 return idx;
             }
         }
     }
 
     return QModelIndex();
 }
 
 QModelIndex TasksModel::makeModelIndex(int row, int childRow) const
 {
     if (row < 0 || row >= rowCount()) {
         return QModelIndex();
     }
 
     const QModelIndex &parent = index(row, 0);
 
     if (childRow == -1) {
         return index(row, 0);
     } else {
         const QModelIndex &parent = index(row, 0);
 
         if (childRow < rowCount(parent)) {
             return parent.child(childRow, 0);
         }
     }
 
     return QModelIndex();
 }
 
 bool TasksModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     // All our filtering occurs at the top-level; anything below always
     // goes through.
     if (sourceParent.isValid()) {
         return true;
     }
 
     const QModelIndex &sourceIndex = sourceModel()->index(sourceRow, 0);
 
     // In inline grouping mode, filter out group parents.
     if (d->flattenGroupsProxyModel && sourceIndex.data(AbstractTasksModel::IsGroupParent).toBool()) {
         return false;
     }
 
     const QString &appId = sourceIndex.data(AbstractTasksModel::AppId).toString();
     const QString &appName = sourceIndex.data(AbstractTasksModel::AppName).toString();
 
     // Filter startup tasks we already have a window task for.
     if (sourceIndex.data(AbstractTasksModel::IsStartup).toBool()) {
         for (int i = 0; i < d->windowTasksModel->rowCount(); ++i) {
             const QModelIndex &windowIndex = d->windowTasksModel->index(i, 0);
 
             if (appId == windowIndex.data(AbstractTasksModel::AppId).toString()
                 || appName == windowIndex.data(AbstractTasksModel::AppName).toString()) {
                 return false;
             }
         }
     }
 
     // Filter launcher tasks we already have a startup or window task for (that
     // got through filtering).
     if (sourceIndex.data(AbstractTasksModel::IsLauncher).toBool()) {
-        const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl();
+        const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
         for (int i = 0; i < d->filterProxyModel->rowCount(); ++i) {
             const QModelIndex &filteredIndex = d->filterProxyModel->index(i, 0);
 
             if (!filteredIndex.data(AbstractTasksModel::IsWindow).toBool() &&
                 !filteredIndex.data(AbstractTasksModel::IsStartup).toBool()) {
                 continue;
             }
 
             const QString &filteredAppId = filteredIndex.data(AbstractTasksModel::AppId).toString();
 
-            if ((!appId.isEmpty() && appId == filteredAppId)
-                || (launcherUrl.isValid() && launcherUrlsMatch(launcherUrl,
-                filteredIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems))) {
+            if ((!appId.isEmpty() && appId == filteredAppId) || (launcherUrl.isValid()
+                && launcherUrl == filteredIndex.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl())) {
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool TasksModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
     // In manual sort mode, sort by map.
     if (d->sortMode == SortManual) {
         return (d->sortedPreFilterRows.indexOf(d->preFilterIndex(left).row())
             < d->sortedPreFilterRows.indexOf(d->preFilterIndex(right).row()));
     }
 
     return d->lessThan(left, right);
 }
 
 }
diff --git a/libtaskmanager/tasktools.cpp b/libtaskmanager/tasktools.cpp
index 932a70af..a072c274 100644
--- a/libtaskmanager/tasktools.cpp
+++ b/libtaskmanager/tasktools.cpp
@@ -1,254 +1,247 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "tasktools.h"
 #include "abstracttasksmodel.h"
 
 #include <KConfigGroup>
 #include <KDesktopFile>
 #include <kemailsettings.h>
 #include <KFileItem>
 #include <KMimeTypeTrader>
 #include <KRun>
 #include <KSharedConfig>
 
 #include <QDir>
 
 namespace TaskManager
 {
 
 AppData appDataFromUrl(const QUrl &url, const QIcon &fallbackIcon)
 {
     AppData data;
     data.url = url;
 
     if (url.hasQuery()) {
         QUrlQuery uQuery(url);
 
         if (uQuery.hasQueryItem(QLatin1String("iconData"))) {
             QString iconData(uQuery.queryItemValue(QLatin1String("iconData")));
             QPixmap pixmap;
             QByteArray bytes = QByteArray::fromBase64(iconData.toLocal8Bit(), QByteArray::Base64UrlEncoding);
             pixmap.loadFromData(bytes);
             data.icon.addPixmap(pixmap);
         }
     }
 
     if (url.isLocalFile() && KDesktopFile::isDesktopFile(url.toLocalFile())) {
         KDesktopFile f(url.toLocalFile());
 
         const KService::Ptr service = KService::serviceByStorageId(f.fileName());
 
         if (service && QUrl::fromLocalFile(service->entryPath()) == url) {
             data.name = service->name();
             data.genericName = service->genericName();
             data.id = service->storageId();
 
             if (data.icon.isNull()) {
                 data.icon = QIcon::fromTheme(service->icon());
             }
         } else if (f.tryExec()) {
             data.name = f.readName();
             data.genericName = f.readGenericName();
             data.id = QUrl::fromLocalFile(f.fileName()).fileName();
 
             if (data.icon.isNull()) {
                 data.icon = QIcon::fromTheme(f.readIcon());
             }
         }
 
         if (data.id.endsWith(".desktop")) {
             data.id = data.id.left(data.id.length() - 8);
         }
     } else if (url.scheme() == QLatin1String("preferred")) {
         data.id = defaultApplication(url);
 
         const KService::Ptr service = KService::serviceByStorageId(data.id);
 
         if (service) {
             QString desktopFile = service->entryPath();
 
             // Update with resolved URL.
             data.url = QUrl::fromLocalFile(desktopFile);
 
             KDesktopFile f(desktopFile);
             KConfigGroup cg(&f, "Desktop Entry");
 
             data.icon = QIcon::fromTheme(f.readIcon());
             const QString exec = cg.readEntry("Exec", QString());
             data.name = cg.readEntry("Name", QString());
 
             if (data.name.isEmpty() && !exec.isEmpty()) {
                 data.name = exec.split(' ').at(0);
             }
 
             data.genericName = f.readGenericName();
         }
     }
 
     if (data.name.isEmpty()) {
         data.name = url.fileName();
     }
 
     if (data.icon.isNull()) {
         data.icon = fallbackIcon;
     }
 
     return data;
 }
 
 QString defaultApplication(const QUrl &url)
 {
     if (url.scheme() != QLatin1String("preferred")) {
         return QString();
     }
 
     const QString &application = url.host();
 
     if (application.isEmpty()) {
         return QString();
     }
 
     if (application.compare(QLatin1String("mailer"), Qt::CaseInsensitive) == 0) {
         KEMailSettings settings;
 
         // In KToolInvocation, the default is kmail; but let's be friendlier.
         QString command = settings.getSetting(KEMailSettings::ClientProgram);
 
         if (command.isEmpty()) {
             if (KService::Ptr kontact = KService::serviceByStorageId(QStringLiteral("kontact"))) {
                 return kontact->storageId();
             } else if (KService::Ptr kmail = KService::serviceByStorageId(QStringLiteral("kmail"))) {
                 return kmail->storageId();
             }
         }
 
         if (!command.isEmpty()) {
             if (settings.getSetting(KEMailSettings::ClientTerminal) == QLatin1String("true")) {
                 KConfigGroup confGroup(KSharedConfig::openConfig(), "General");
                 const QString preferredTerminal = confGroup.readPathEntry("TerminalApplication",
                                                   QStringLiteral("konsole"));
                 command = preferredTerminal + QLatin1String(" -e ") + command;
             }
 
             return command;
         }
     } else if (application.compare(QLatin1String("browser"), Qt::CaseInsensitive) == 0) {
         KConfigGroup config(KSharedConfig::openConfig(), "General");
         QString browserApp = config.readPathEntry("BrowserApplication", QString());
 
         if (browserApp.isEmpty()) {
             const KService::Ptr htmlApp = KMimeTypeTrader::self()->preferredService(QStringLiteral("text/html"));
 
             if (htmlApp) {
                 browserApp = htmlApp->storageId();
             }
         } else if (browserApp.startsWith('!')) {
             browserApp = browserApp.mid(1);
         }
 
         return browserApp;
     } else if (application.compare(QLatin1String("terminal"), Qt::CaseInsensitive) == 0) {
         KConfigGroup confGroup(KSharedConfig::openConfig(), "General");
 
         return confGroup.readPathEntry("TerminalApplication", QStringLiteral("konsole"));
     } else if (application.compare(QLatin1String("filemanager"), Qt::CaseInsensitive) == 0) {
         KService::Ptr service = KMimeTypeTrader::self()->preferredService(QStringLiteral("inode/directory"));
 
         if (service) {
             return service->storageId();
         }
     } else if (application.compare(QLatin1String("windowmanager"), Qt::CaseInsensitive) == 0) {
         KConfig cfg(QStringLiteral("ksmserverrc"), KConfig::NoGlobals);
         KConfigGroup confGroup(&cfg, "General");
 
         return confGroup.readEntry("windowManager", QStringLiteral("kwin"));
     } else if (KService::Ptr service = KMimeTypeTrader::self()->preferredService(application)) {
         return service->storageId();
     } else {
         // Try the files in share/apps/kcm_componentchooser/*.desktop.
         QStringList directories = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("kcm_componentchooser"), QStandardPaths::LocateDirectory);
         QStringList services;
 
         foreach(const QString& directory, directories) {
             QDir dir(directory);
             foreach(const QString& f, dir.entryList(QStringList("*.desktop")))
                 services += dir.absoluteFilePath(f);
         }
 
         foreach (const QString & service, services) {
             KConfig config(service, KConfig::SimpleConfig);
             KConfigGroup cg = config.group(QByteArray());
             const QString type = cg.readEntry("valueName", QString());
 
             if (type.compare(application, Qt::CaseInsensitive) == 0) {
                 KConfig store(cg.readPathEntry("storeInFile", QStringLiteral("null")));
                 KConfigGroup storeCg(&store, cg.readEntry("valueSection", QString()));
                 const QString exec = storeCg.readPathEntry(cg.readEntry("valueName", "kcm_componenchooser_null"),
                                      cg.readEntry("defaultImplementation", QString()));
 
                 if (!exec.isEmpty()) {
                     return exec;
                 }
 
                 break;
             }
         }
     }
 
     return QString("");
 }
 
-bool launcherUrlsMatch(const QUrl &_a, const QUrl &_b, UrlComparisonMode mode)
+bool launcherUrlsMatch(const QUrl &a, const QUrl &b, UrlComparisonMode mode)
 {
     if (mode == IgnoreQueryItems) {
-        QUrl a(_a);
-        a.setQuery(QUrlQuery());
-
-        QUrl b(_b);
-        b.setQuery(QUrlQuery());
-
-        return (a == b);
+        return (a.adjusted(QUrl::RemoveQuery) == b.adjusted(QUrl::RemoveQuery));
     }
 
-    return (_a == _b);
+    return (a == b);
 }
 
 bool appsMatch(const QModelIndex &a, const QModelIndex &b)
 {
     const QString &aAppId = a.data(AbstractTasksModel::AppId).toString();
     const QString &bAppId = b.data(AbstractTasksModel::AppId).toString();
 
     if (!aAppId.isEmpty() && aAppId == bAppId) {
         return true;
     }
 
-    const QUrl &aLauncherUrl = a.data(AbstractTasksModel::LauncherUrl).toUrl();
-    const QUrl &bLauncherUrl = b.data(AbstractTasksModel::LauncherUrl).toUrl();
+    const QUrl &aUrl = a.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
+    const QUrl &bUrl = b.data(AbstractTasksModel::LauncherUrlWithoutIcon).toUrl();
 
-    if (aLauncherUrl.isValid() && launcherUrlsMatch(aLauncherUrl, bLauncherUrl,
-        IgnoreQueryItems)) {
+    if (aUrl.isValid() && aUrl == bUrl) {
         return true;
     }
 
     return false;
 }
 
 }
diff --git a/libtaskmanager/tasktools.h b/libtaskmanager/tasktools.h
index fcc76c70..122e2320 100644
--- a/libtaskmanager/tasktools.h
+++ b/libtaskmanager/tasktools.h
@@ -1,102 +1,106 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef TASKTOOLS_H
 #define TASKTOOLS_H
 
 #include "taskmanager_export.h"
 
 #include <QIcon>
 #include <QModelIndex>
 #include <QUrl>
 
 namespace TaskManager
 {
 
 struct AppData
 {
     QString id; // Application id (*.desktop sans extension).
     QString name; // Application name.
     QString genericName; // Generic application name.
     QIcon icon;
     QUrl url;
 };
 
 enum UrlComparisonMode {
      Strict = 0,
      IgnoreQueryItems
 };
 
 /**
  * Fills in and returns an AppData struct based on the given URL.
  *
  * If the URL contains iconData in its query string, it is decoded and
  * set as AppData.icon, taking precedence over normal icon discovery.
  *
  * If the URL is using the preferred:// scheme, the URL it resolves to
  * is set as AppData.url.
  *
  * The supplied fallback icon is set as AppData.icon if no other icon
  * could be found.
  *
  * @see defaultApplication
  * @param url A URL to a .desktop file or executable, or a preferred:// URL.
  * @param fallbackIcon An icon to use when none could be read from the URL or
  * otherwise found.
  * @returns @c AppData filled in based on the given URL.
  */
 TASKMANAGER_EXPORT AppData appDataFromUrl(const QUrl &url, const QIcon &fallbackIcon = QIcon());
 
 /**
  * Returns an application id for an URL using the preferred:// scheme.
  *
  * Recognized values for the host component of the URL are:
  * - "browser"
  * - "mailer"
  * - "terminal"
  * - "windowmanager"
  *
  * If the host component matches none of the above, an attempt is made
  * to match to application links stored in kcm_componentchooser/.
  *
  * @param url A URL using the preferred:// scheme.
  * @returns an application id for the given URL.
  **/
 TASKMANAGER_EXPORT QString defaultApplication(const QUrl &url);
 
 /**
- * Compares two launcher URLs either strictly or ignoring the query string.
- *
- * In launcher URLs, the query string is used to hold metadata such as an
- * icon. When comparing tasks by launcher URL, this metadata should usually
- * be ignored. This function serves this need.
+ * Convenience function to compare two launcher URLs either strictly
+ * or ignoring their query strings.
  *
  * @see LauncherTasksModel
  * @param a The first launcher URL.
  * @param b The second launcher URL.
  * @param c The comparison mode. Either Strict or IgnoreQueryItems.
  * @returns @c true if the URLs match.
  **/
 TASKMANAGER_EXPORT bool launcherUrlsMatch(const QUrl &a, const QUrl &b, UrlComparisonMode mode = Strict);
 
+/**
+ * Determines whether tasks model entries belong to the same app.
+ *
+ * @param a The first model index.
+ * @param b The second model index.
+ * @returns @c true if the model entries belong to the same app.
+ **/
 TASKMANAGER_EXPORT bool appsMatch(const QModelIndex &a, const QModelIndex &b);
 }
 
 #endif
diff --git a/libtaskmanager/waylandtasksmodel.cpp b/libtaskmanager/waylandtasksmodel.cpp
index 8e362306..2cbdf188 100644
--- a/libtaskmanager/waylandtasksmodel.cpp
+++ b/libtaskmanager/waylandtasksmodel.cpp
@@ -1,502 +1,508 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "waylandtasksmodel.h"
 
 #include <KActivities/ResourceInstance>
 #include <KRun>
 #include <KService>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/surface.h>
 
 #include <QGuiApplication>
 #include <QQuickItem>
 #include <QQuickWindow>
 #include <QSet>
 #include <QUrl>
 #include <QWindow>
 
 namespace TaskManager
 {
 
 class WaylandTasksModel::Private
 {
 public:
     Private(WaylandTasksModel *q);
     QList<KWayland::Client::PlasmaWindow*> windows;
     QHash<KWayland::Client::PlasmaWindow*, KService::Ptr> serviceCache;
     KWayland::Client::PlasmaWindowManagement *windowManagement = nullptr;
 
     void initWayland();
     void addWindow(KWayland::Client::PlasmaWindow *window);
     void dataChanged(KWayland::Client::PlasmaWindow *window, int role);
+    void dataChanged(KWayland::Client::PlasmaWindow *window, const QVector<int> &roles);
 
 private:
     WaylandTasksModel *q;
 };
 
 WaylandTasksModel::Private::Private(WaylandTasksModel *q)
     : q(q)
 {
 }
 
 void WaylandTasksModel::Private::initWayland()
 {
     if (!QGuiApplication::platformName().startsWith(QLatin1String("wayland"), Qt::CaseInsensitive)) {
         return;
     }
 
     KWayland::Client::ConnectionThread *connection = KWayland::Client::ConnectionThread::fromApplication(q);
 
     if (!connection) {
         return;
     }
 
     KWayland::Client::Registry *registry = new KWayland::Client::Registry(q);
     registry->create(connection);
 
     QObject::connect(registry, &KWayland::Client::Registry::plasmaWindowManagementAnnounced, [this, registry] (quint32 name, quint32 version) {
             windowManagement = registry->createPlasmaWindowManagement(name, version, q);
 
             QObject::connect(windowManagement, &KWayland::Client::PlasmaWindowManagement::interfaceAboutToBeReleased, q,
                 [this] {
                     q->beginResetModel();
                     windows.clear();
                     q->endResetModel();
                 }
             );
 
             QObject::connect(windowManagement, &KWayland::Client::PlasmaWindowManagement::windowCreated, q,
                 [this](KWayland::Client::PlasmaWindow *window) {
                     addWindow(window);
                 }
             );
 
             for (auto it = windowManagement->windows().constBegin(); it != windowManagement->windows().constEnd(); ++it) {
                 addWindow(*it);
             }
         }
     );
 
     registry->setup();
 }
 
 void WaylandTasksModel::Private::addWindow(KWayland::Client::PlasmaWindow *window)
 {
     if (windows.indexOf(window) != -1) {
         return;
     }
 
     const int count = windows.count();
 
     q->beginInsertRows(QModelIndex(), count, count);
 
     windows.append(window);
 
     KService::Ptr service = KService::serviceByStorageId(window->appId());
 
     if (service) {
         serviceCache.insert(window, service);
     }
 
     q->endInsertRows();
 
     auto removeWindow = [window, this] {
         const int row = windows.indexOf(window);
         if (row != -1) {
             q->beginRemoveRows(QModelIndex(), row, row);
             windows.removeAt(row);
             serviceCache.remove(window);
             q->endRemoveRows();
         }
     };
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::unmapped, q, removeWindow);
     QObject::connect(window, &QObject::destroyed, q, removeWindow);
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::titleChanged, q,
         [window, this] { dataChanged(window, Qt::DisplayRole); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::iconChanged, q,
         [window, this] { dataChanged(window, Qt::DecorationRole); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::appIdChanged, q,
         [window, this] {
             KService::Ptr service = KService::serviceByStorageId(window->appId());
 
             if (service) {
                 serviceCache.insert(window, service);
             } else {
                 serviceCache.remove(window);
             }
 
-            dataChanged(window, AppId);
+            dataChanged(window, QVector<int>{AppId, AppName, GenericName,
+                LauncherUrl, LauncherUrlWithoutIcon});
         }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::activeChanged, q,
         [window, this] { this->dataChanged(window, IsActive); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::closeableChanged, q,
         [window, this] { this->dataChanged(window, IsClosable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::movableChanged, q,
         [window, this] { this->dataChanged(window, IsMovable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::resizableChanged, q,
         [window, this] { this->dataChanged(window, IsResizable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::fullscreenableChanged, q,
         [window, this] { this->dataChanged(window, IsFullScreenable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::fullscreenChanged, q,
         [window, this] { this->dataChanged(window, IsFullScreen); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::maximizeableChanged, q,
         [window, this] { this->dataChanged(window, IsMaximizable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::maximizedChanged, q,
         [window, this] { this->dataChanged(window, IsMaximized); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::minimizeableChanged, q,
         [window, this] { this->dataChanged(window, IsMinimizable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::minimizedChanged, q,
         [window, this] { this->dataChanged(window, IsMinimized); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::keepAboveChanged, q,
         [window, this] { this->dataChanged(window, IsKeepAbove); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::keepBelowChanged, q,
         [window, this] { this->dataChanged(window, IsKeepBelow); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::shadeableChanged, q,
         [window, this] { this->dataChanged(window, IsShadeable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::virtualDesktopChangeableChanged, q,
         [window, this] { this->dataChanged(window, IsVirtualDesktopChangeable); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::virtualDesktopChanged, q,
         [window, this] { this->dataChanged(window, VirtualDesktop); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::onAllDesktopsChanged, q,
         [window, this] { this->dataChanged(window, IsOnAllVirtualDesktops); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::demandsAttentionChanged, q,
         [window, this] { this->dataChanged(window, IsDemandingAttention); }
     );
 
     QObject::connect(window, &KWayland::Client::PlasmaWindow::skipTaskbarChanged, q,
         [window, this] { this->dataChanged(window, SkipTaskbar); }
     );
 }
 
 void WaylandTasksModel::Private::dataChanged(KWayland::Client::PlasmaWindow *window, int role)
 {
     QModelIndex idx = q->index(windows.indexOf(window));
     emit q->dataChanged(idx, idx, QVector<int>{role});
 }
 
+void WaylandTasksModel::Private::dataChanged(KWayland::Client::PlasmaWindow *window, const QVector<int> &roles)
+{
+    QModelIndex idx = q->index(windows.indexOf(window));
+    emit q->dataChanged(idx, idx, roles);
+}
+
 WaylandTasksModel::WaylandTasksModel(QObject *parent)
     : AbstractTasksModel(parent)
     , d(new Private(this))
 {
     d->initWayland();
 }
 
 WaylandTasksModel::~WaylandTasksModel() = default;
 
 QVariant WaylandTasksModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() >= d->windows.count()) {
         return QVariant();
     }
 
     KWayland::Client::PlasmaWindow *window = d->windows.at(index.row());
 
     if (role == Qt::DisplayRole) {
         return window->title();
     } else if (role == Qt::DecorationRole) {
         return window->icon();
     } else if (role == AppId) {
         return window->appId();
     } else if (role == AppName) {
         if (d->serviceCache.contains(window)) {
             return d->serviceCache.value(window)->name();
         } else {
             return window->title();
         }
     } else if (role == GenericName) {
         if (d->serviceCache.contains(window)) {
             return d->serviceCache.value(window)->genericName();
         }
-    } else if (role == LauncherUrl) {
+    } else if (role == LauncherUrl || role == LauncherUrlWithoutIcon) {
         if (d->serviceCache.contains(window)) {
             return QUrl::fromLocalFile(d->serviceCache.value(window)->entryPath());
-        } else {
-            return window->title();
         }
     } else if (role == IsWindow) {
         return true;
     } else if (role == IsActive) {
         return window->isActive();
     } else if (role == IsClosable) {
         return window->isCloseable();
     } else if (role == IsMovable) {
         return window->isMovable();
     } else if (role == IsResizable) {
         return window->isResizable();
     } else if (role == IsMaximizable) {
         return window->isMaximizeable();
     } else if (role == IsMaximized) {
         return window->isMaximized();
     } else if (role == IsMinimizable) {
         return window->isMinimizeable();
     } else if (role == IsMinimized) {
         return window->isMinimized();
     } else if (role == IsKeepAbove) {
         return window->isKeepAbove();
     } else if (role == IsKeepBelow) {
         return window->isKeepBelow();
     } else if (role == IsFullScreenable) {
         return window->isFullscreenable();
     } else if (role == IsFullScreen) {
         return window->isFullscreen();
     } else if (role == IsShadeable) {
         return window->isShadeable();
     } else if (role == IsShaded) {
         return window->isShaded();
     } else if (role == IsVirtualDesktopChangeable) {
         return window->isVirtualDesktopChangeable();
     } else if (role == VirtualDesktop) {
         return window->virtualDesktop();
     } else if (role == IsOnAllVirtualDesktops) {
         return window->isOnAllDesktops();
     } else if (role == Screen) {
         // FIXME Implement.
     } else if (role == Activities) {
         // FIXME Implement.
     } else if (role == IsDemandingAttention) {
         return window->isDemandingAttention();
     } else if (role == SkipTaskbar) {
         return window->skipTaskbar();
     }
 
     return QVariant();
 }
 
 int WaylandTasksModel::rowCount(const QModelIndex &parent) const
 {
     return parent.isValid() ? 0 : d->windows.count();
 }
 
 QModelIndex WaylandTasksModel::index(int row, int column, const QModelIndex &parent) const
 {
     return hasIndex(row, column, parent) ? createIndex(row, column, d->windows.at(row)) : QModelIndex();
 }
 
 void WaylandTasksModel::requestActivate(const QModelIndex &index)
 {
     // FIXME Lacks transient handling of the XWindows version.
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestActivate();
 }
 
 void WaylandTasksModel::requestNewInstance(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     KWayland::Client::PlasmaWindow* window = d->windows.at(index.row());
 
     if (d->serviceCache.contains(window)) {
         const KService::Ptr service = d->serviceCache.value(window);
 
         new KRun(QUrl::fromLocalFile(service->entryPath()), 0, false);
 
         KActivities::ResourceInstance::notifyAccessed(QUrl("applications:" + service->storageId()),
             "org.kde.libtaskmanager");
     }
 }
 
 void WaylandTasksModel::requestClose(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestClose();
 }
 
 void WaylandTasksModel::requestMove(const QModelIndex &index)
 {
     // FIXME Move-to-desktop logic from XWindows version. (See also others.)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestMove();
 }
 
 void WaylandTasksModel::requestResize(const QModelIndex &index)
 {
     // FIXME Move-to-desktop logic from XWindows version. (See also others.)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestResize();
 }
 
 void WaylandTasksModel::requestToggleMinimized(const QModelIndex &index)
 {
     // FIXME Move-to-desktop logic from XWindows version. (See also others.)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestToggleMinimized();
 }
 
 void WaylandTasksModel::requestToggleMaximized(const QModelIndex &index)
 {
     // FIXME Move-to-desktop logic from XWindows version. (See also others.)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestToggleMaximized();
 }
 
 void WaylandTasksModel::requestToggleKeepAbove(const QModelIndex &index)
 {
     Q_UNUSED(index)
 
     // FIXME Implement.
 }
 
 void WaylandTasksModel::requestToggleKeepBelow(const QModelIndex &index)
 {
     Q_UNUSED(index)
 
     // FIXME Implement.
 }
 
 void WaylandTasksModel::requestToggleFullScreen(const QModelIndex &index)
 {
     Q_UNUSED(index)
 
     // FIXME Implement.
 }
 
 void WaylandTasksModel::requestToggleShaded(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestToggleShaded();
 }
 
 void WaylandTasksModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop)
 {
     // FIXME Lacks add-new-desktop code from XWindows version.
     // FIXME Does this do the set-on-all-desktops stuff from the XWindows version?
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     d->windows.at(index.row())->requestVirtualDesktop(desktop);
 }
 
 void WaylandTasksModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate)
 {
     /*
     FIXME: This introduces the dependency on Qt5::Quick. I might prefer
     reversing this and publishing the window pointer through the model,
     then calling PlasmaWindow::setMinimizeGeometry in the applet backend,
     rather than hand delegate items into the lib, keeping the lib more UI-
     agnostic.
     */
 
     Q_UNUSED(geometry)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const QQuickItem *item = qobject_cast<const QQuickItem *>(delegate);
 
     if (!item || !item->parentItem() || !item->window()) {
         return;
     }
 
     QWindow *itemWindow = item->window();
 
     if (!itemWindow) {
         return;
     }
 
     using namespace KWayland::Client;
     Surface *surface = Surface::fromWindow(itemWindow);
 
     if (!surface) {
         return;
     }
 
     QRect rect(item->x(), item->y(), item->width(), item->height());
     rect.moveTopLeft(item->parentItem()->mapToScene(rect.topLeft()).toPoint());
 
     KWayland::Client::PlasmaWindow *window = d->windows.at(index.row());
 
     window->setMinimizedGeometry(surface, rect);
 }
 
 }
diff --git a/libtaskmanager/xwindowtasksmodel.cpp b/libtaskmanager/xwindowtasksmodel.cpp
index 33670c09..3c9943d8 100644
--- a/libtaskmanager/xwindowtasksmodel.cpp
+++ b/libtaskmanager/xwindowtasksmodel.cpp
@@ -1,1218 +1,1220 @@
 /********************************************************************
 Copyright 2016  Eike Hein <hein@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "xwindowtasksmodel.h"
 #include "tasktools.h"
 
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KIconLoader>
 #include <KRun>
 #include <KService>
 #include <KServiceTypeTrader>
 #include <KSharedConfig>
 #include <KStartupInfo>
 #include <KSycoca>
 #include <KWindowInfo>
 #include <KWindowSystem>
 #include <processcore/processes.h>
 #include <processcore/process.h>
 
 #include <QBuffer>
 #include <QDir>
 #include <QIcon>
 #include <QFile>
 #include <QGuiApplication>
 #include <QRegularExpression>
 #include <QScreen>
 #include <QSet>
 #include <QStandardPaths>
 #include <QTimer>
 #include <QX11Info>
 
 #include <netwm.h>
 
 namespace TaskManager
 {
 
 static const NET::Properties windowInfoFlags = NET::WMState | NET::XAWMState | NET::WMDesktop |
         NET::WMVisibleName | NET::WMGeometry |
         NET::WMWindowType;
 static const NET::Properties2 windowInfoFlags2 = NET::WM2WindowClass | NET::WM2AllowedActions;
 
 class XWindowTasksModel::Private
 {
 public:
     Private(XWindowTasksModel *q);
     ~Private();
 
     QVector<WId> windows;
     QSet<WId> transients;
     QHash<WId, WId> transientsDemandingAttention;
     QHash<WId, KWindowInfo*> windowInfoCache;
     QHash<WId, AppData> appDataCache;
     QHash<WId, QRect> delegateGeometries;
     WId activeWindow = -1;
     KSharedConfig::Ptr rulesConfig;
     KDirWatch *configWatcher = nullptr;
     QTimer sycocaChangeTimer;
 
     void init();
     void addWindow(WId window);
     void removeWindow(WId window);
     void windowChanged(WId window, NET::Properties properties, NET::Properties2 properties2);
     void transientChanged(WId window, NET::Properties properties, NET::Properties2 properties2);
     void dataChanged(WId window, const QVector<int> &roles);
 
     KWindowInfo* windowInfo(WId window);
     AppData appData(WId window);
 
     QIcon icon(WId window);
     QString mimeType() const;
     QUrl windowUrl(WId window);
-    QUrl launcherUrl(WId window);
+    QUrl launcherUrl(WId window, bool encodeFallbackIcon = true);
     QUrl serviceUrl(int pid, const QString &type, const QStringList &cmdRemovals);
     KService::List servicesFromPid(int pid);
     int screen(WId window);
     QStringList activities(WId window);
     bool demandsAttention(WId window);
 
 private:
     XWindowTasksModel *q;
 };
 
 XWindowTasksModel::Private::Private(XWindowTasksModel *q)
     : q(q)
 {
 }
 
 XWindowTasksModel::Private::~Private()
 {
     qDeleteAll(windowInfoCache);
     windowInfoCache.clear();
 }
 
 void XWindowTasksModel::Private::init()
 {
     rulesConfig = KSharedConfig::openConfig(QStringLiteral("taskmanagerrulesrc"));
     configWatcher = new KDirWatch(q);
 
     foreach (const QString &location, QStandardPaths::standardLocations(QStandardPaths::ConfigLocation)) {
         configWatcher->addFile(location + QLatin1String("/taskmanagerrulesrc"));
     }
 
     QObject::connect(configWatcher, &KDirWatch::dirty, [this] { rulesConfig->reparseConfiguration(); });
     QObject::connect(configWatcher, &KDirWatch::created, [this] { rulesConfig->reparseConfiguration(); });
     QObject::connect(configWatcher, &KDirWatch::deleted, [this] { rulesConfig->reparseConfiguration(); });
 
     sycocaChangeTimer.setSingleShot(true);
     sycocaChangeTimer.setInterval(100);
 
     QObject::connect(&sycocaChangeTimer, &QTimer::timeout, q,
         [this]() {
             if (!windows.count()) {
                 return;
             }
 
             appDataCache.clear();
 
             // Emit changes of all roles satisfied from app data cache.
             q->dataChanged(q->index(0, 0),  q->index(windows.count() - 1, 0),
                 QVector<int>{Qt::DecorationRole, AbstractTasksModel::AppId,
                 AbstractTasksModel::AppName, AbstractTasksModel::GenericName,
                 AbstractTasksModel::LauncherUrl});
         }
     );
 
     void (KSycoca::*myDatabaseChangeSignal)(const QStringList &) = &KSycoca::databaseChanged;
     QObject::connect(KSycoca::self(), myDatabaseChangeSignal, q,
         [this](const QStringList &changedResources) {
             if (changedResources.contains(QLatin1String("services"))
                 || changedResources.contains(QLatin1String("apps"))
                 || changedResources.contains(QLatin1String("xdgdata-apps"))) {
                 sycocaChangeTimer.start();
             }
         }
     );
 
     QObject::connect(KWindowSystem::self(), &KWindowSystem::windowAdded, q,
         [this](WId window) {
             addWindow(window);
         }
     );
 
     QObject::connect(KWindowSystem::self(), &KWindowSystem::windowRemoved, q,
         [this](WId window) {
             removeWindow(window);
         }
     );
 
     void (KWindowSystem::*myWindowChangeSignal)(WId window,
         NET::Properties properties, NET::Properties2 properties2) = &KWindowSystem::windowChanged;
     QObject::connect(KWindowSystem::self(), myWindowChangeSignal, q,
         [this](WId window, NET::Properties properties, NET::Properties2 properties2) {
             windowChanged(window, properties, properties2);
         }
     );
 
     // Update IsActive for previously- and newly-active windows.
     QObject::connect(KWindowSystem::self(), &KWindowSystem::activeWindowChanged, q,
         [this](WId window) {
             const WId oldActiveWindow = activeWindow;
             activeWindow = window;
 
             int row = windows.indexOf(oldActiveWindow);
 
             if (row != -1) {
                 dataChanged(oldActiveWindow, QVector<int>{IsActive});
             }
 
             row = windows.indexOf(window);
 
             if (row != -1) {
                 dataChanged(window, QVector<int>{IsActive});
             }
         }
     );
 
     activeWindow = KWindowSystem::activeWindow();
 
     // Add existing windows.
     foreach(const WId window, KWindowSystem::windows()) {
         addWindow(window);
     }
 }
 
 void XWindowTasksModel::Private::addWindow(WId window)
 {
     // Don't add window twice.
     if (windows.contains(window)) {
         return;
     }
 
     KWindowInfo info(window,
                      NET::WMWindowType | NET::WMState | NET::WMName | NET::WMVisibleName,
                      NET::WM2TransientFor);
 
     NET::WindowType wType = info.windowType(NET::NormalMask | NET::DesktopMask | NET::DockMask |
                                             NET::ToolbarMask | NET::MenuMask | NET::DialogMask |
                                             NET::OverrideMask | NET::TopMenuMask |
                                             NET::UtilityMask | NET::SplashMask);
 
     const WId leader = info.transientFor();
 
     // Handle transient.
     if (leader > 0 && leader != window && leader != QX11Info::appRootWindow()
         && !transients.contains(window) && windows.contains(leader)) {
         transients.insert(window);
 
         // Update demands attention state for leader.
         if (info.state() & NET::DemandsAttention && windows.contains(leader)) {
             transientsDemandingAttention.insertMulti(leader, window);
             dataChanged(leader, QVector<int>{IsDemandingAttention});
         }
 
         return;
     }
 
     // Ignore NET::Tool and other special window types; they are not considered tasks.
     if (wType != NET::Normal && wType != NET::Override && wType != NET::Unknown &&
         wType != NET::Dialog && wType != NET::Utility) {
 
         return;
     }
 
     const int count = windows.count();
     q->beginInsertRows(QModelIndex(), count, count);
     windows.append(window);
     q->endInsertRows();
 }
 
 void XWindowTasksModel::Private::removeWindow(WId window)
 {
     const int row = windows.indexOf(window);
 
     if (row != -1) {
         q->beginRemoveRows(QModelIndex(), row, row);
         windows.removeAt(row);
         transientsDemandingAttention.remove(window);
         windowInfoCache.remove(window);
         appDataCache.remove(window);
         delegateGeometries.remove(window);
         q->endRemoveRows();
     } else { // Could be a transient.
         // Removing a transient might change the demands attention state of the leader.
         if (transients.remove(window)) {
             QMutableHashIterator<WId, WId> i(transientsDemandingAttention);
             WId leader = 0;
 
             while (i.hasNext()) {
                 i.next();
 
                 if (i.value() == window) {
                     if (leader == 0) {
                         leader = i.key();
                     }
 
                     i.remove();
                 }
             }
 
             if (leader != 0) {
                 dataChanged(leader, QVector<int>{IsDemandingAttention});
             }
         }
     }
 
     if (activeWindow == window) {
         activeWindow = -1;
     }
 }
 
 void XWindowTasksModel::Private::transientChanged(WId window, NET::Properties properties, NET::Properties2 properties2)
 {
     // Changes to a transient's state might change demands attention state for leader.
     if (properties & (NET::WMState | NET::XAWMState)) {
         const KWindowInfo info(window, NET::WMState | NET::XAWMState, NET::WM2TransientFor);
         const WId leader = info.transientFor();
 
         if (!windows.contains(leader)) {
             return;
         }
 
         if (info.state() & NET::DemandsAttention) {
             if (!transientsDemandingAttention.values(leader).contains(window)) {
                 transientsDemandingAttention.insertMulti(leader, window);
                 dataChanged(leader, QVector<int>{IsDemandingAttention});
             }
         } else if (transientsDemandingAttention.remove(window)) {
             dataChanged(leader, QVector<int>{IsDemandingAttention});
         }
     // Leader might have changed.
     } else if (properties2 & NET::WM2TransientFor) {
         const KWindowInfo info(window, NET::WMState | NET::XAWMState, NET::WM2TransientFor);
 
         if (info.state() & NET::DemandsAttention) {
             WId oldLeader = info.transientFor();
             QMutableHashIterator<WId, WId> i(transientsDemandingAttention);
 
             while (i.hasNext()) {
                 i.next();
 
                 if (i.value() == window) {
                     i.remove();
                     oldLeader = i.key();
                 }
             }
 
             if (oldLeader != 0) {
                 const WId leader = info.transientFor();
                 transientsDemandingAttention.insertMulti(leader, window);
                 dataChanged(oldLeader, QVector<int>{IsDemandingAttention});
                 dataChanged(leader, QVector<int>{IsDemandingAttention});
             }
         }
     }
 }
 
 void XWindowTasksModel::Private::windowChanged(WId window, NET::Properties properties, NET::Properties2 properties2)
 {
     if (transients.contains(window)) {
         transientChanged(window, properties, properties2);
 
         return;
     }
 
     bool wipeInfoCache = false;
     bool wipeAppDataCache = false;
     QVector<int> changedRoles;
 
     if (properties & (NET::WMName | NET::WMVisibleName | NET::WM2WindowClass | NET::WMPid)
         || properties2 & NET::WM2WindowClass) {
         wipeInfoCache = true;
         wipeAppDataCache = true;
         changedRoles << Qt::DisplayRole << Qt::DecorationRole << AppId << AppName << GenericName << LauncherUrl;
     }
 
     if ((properties & NET::WMIcon) && !changedRoles.contains(Qt::DecorationRole)) {
         changedRoles << Qt::DecorationRole;
     }
 
     // FIXME TODO: It might be worth keeping track of which windows were demanding
     // attention (or not) to avoid emitting this role on every state change, as
     // TaskGroupingProxyModel needs to check for group-ability when a change to it
     // is announced and the queried state is false.
     if (properties & (NET::WMState | NET::XAWMState)) {
         wipeInfoCache = true;
         changedRoles << IsFullScreen << IsMaximized << IsMinimized << IsKeepAbove << IsKeepBelow;
         changedRoles << IsShaded << IsDemandingAttention << SkipTaskbar;
     }
 
     if (properties2 & NET::WM2AllowedActions) {
         wipeInfoCache = true;
         changedRoles << IsClosable << IsMovable << IsResizable << IsMaximizable << IsMinimizable;
         changedRoles << IsFullScreenable << IsShadeable << IsVirtualDesktopChangeable;
     }
 
     if (properties & NET::WMDesktop) {
         wipeInfoCache = true;
         changedRoles << VirtualDesktop << IsOnAllVirtualDesktops;
     }
 
     if (properties & NET::WMGeometry) {
         wipeInfoCache = true;
         changedRoles << Screen;
     }
 
     if (properties2 & NET::WM2Activities) {
         changedRoles << Activities;
     }
 
     if (wipeInfoCache) {
         delete windowInfoCache.take(window);
     }
 
     if (wipeAppDataCache) {
         appDataCache.remove(window);
     }
 
     if (!changedRoles.isEmpty()) {
         dataChanged(window, changedRoles);
     }
 }
 
 void XWindowTasksModel::Private::dataChanged(WId window, const QVector<int> &roles)
 {
     const int i = windows.indexOf(window);
 
     if (i == -1) {
         return;
     }
 
     QModelIndex idx = q->index(i);
     emit q->dataChanged(idx, idx, roles);
 }
 
 KWindowInfo* XWindowTasksModel::Private::windowInfo(WId window)
 {
     if (!windowInfoCache.contains(window)) {
         KWindowInfo *info = new KWindowInfo(window, windowInfoFlags, windowInfoFlags2);
         windowInfoCache.insert(window, info);
 
         return info;
     }
 
     return windowInfoCache.value(window);
 }
 
 AppData XWindowTasksModel::Private::appData(WId window)
 {
     if (!appDataCache.contains(window)) {
         const AppData &data = appDataFromUrl(windowUrl(window));
         appDataCache.insert(window, data);
 
         return data;
     }
 
     return appDataCache.value(window);
 }
 
 QIcon XWindowTasksModel::Private::icon(WId window)
 {
     const AppData &app = appData(window);
 
     if (!app.icon.isNull()) {
         return app.icon;
     }
 
     QIcon icon;
 
     icon.addPixmap(KWindowSystem::icon(window, KIconLoader::SizeSmall, KIconLoader::SizeSmall, false));
     icon.addPixmap(KWindowSystem::icon(window, KIconLoader::SizeSmallMedium, KIconLoader::SizeSmallMedium, false));
     icon.addPixmap(KWindowSystem::icon(window, KIconLoader::SizeMedium, KIconLoader::SizeMedium, false));
     icon.addPixmap(KWindowSystem::icon(window, KIconLoader::SizeLarge, KIconLoader::SizeLarge, false));
 
     return icon;
 }
 
 QString XWindowTasksModel::Private::mimeType() const
 {
     return QStringLiteral("windowsystem/winid");
 }
 
 QUrl XWindowTasksModel::Private::windowUrl(WId window)
 {
     QUrl url;
 
     const KWindowInfo *info = windowInfo(window);
     const QString &classClass = info->windowClassClass();
     const QString &className = info->windowClassName();
 
     KService::List services;
     bool triedPid = false;
 
     if (!(classClass.isEmpty() && className.isEmpty())) {
         int pid = NETWinInfo(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMPid, 0).pid();
 
         // For KCModules, if we matched on window class, etc, we would end up matching to kcmshell4 - but we are more than likely
         // interested in the actual control module. Therefore we obtain this via the commandline. This commandline may contain
         // "kdeinit4:" or "[kdeinit]", so we remove these first.
         // FIXME This looks like ancient old crap we can do better now.
         if ("Kcmshell5" == classClass) {
             url = serviceUrl(pid, QStringLiteral("KCModule"), QStringList() << QStringLiteral("kdeinit5:") << QStringLiteral("[kdeinit]"));
 
             if (!url.isEmpty()) {
                 return url;
             }
         }
 
         // Check to see if this wmClass matched a saved one ...
         KConfigGroup grp(rulesConfig, "Mapping");
         KConfigGroup set(rulesConfig, "Settings");
 
         // Some apps have different launchers depending upon command line ...
         QStringList matchCommandLineFirst = set.readEntry("MatchCommandLineFirst", QStringList());
 
         if (!classClass.isEmpty() && matchCommandLineFirst.contains(classClass)) {
             triedPid = true;
             services = servicesFromPid(pid);
         }
 
         // Try to match using className also.
         if (!className.isEmpty() && matchCommandLineFirst.contains("::"+className)) {
             triedPid = true;
             services = servicesFromPid(pid);
         }
 
         // If the user has manualy set a mapping, respect this first...
         QString mapped(grp.readEntry(classClass + "::" + className, QString()));
 
         if (mapped.endsWith(QLatin1String(".desktop"))) {
             url = mapped;
             return url;
         }
 
         if (!classClass.isEmpty()) {
             if (mapped.isEmpty()) {
                 mapped = grp.readEntry(classClass, QString());
 
                 if (mapped.endsWith(QLatin1String(".desktop"))) {
                     url = mapped;
                     return url;
                 }
             }
 
             // Some apps, such as Wine, cannot use className to map to launcher name - as Wine itself is not a GUI app
             // So, Settings/ManualOnly lists window classes where the user will always have to manualy set the launcher ...
             QStringList manualOnly = set.readEntry("ManualOnly", QStringList());
 
             if (!classClass.isEmpty() && manualOnly.contains(classClass)) {
                 return url;
             }
 
             KConfigGroup rewriteRulesGroup(rulesConfig, QStringLiteral("Rewrite Rules"));
             if (rewriteRulesGroup.hasGroup(classClass)) {
                 KConfigGroup rewriteGroup(&rewriteRulesGroup, classClass);
 
                 const QStringList &rules = rewriteGroup.groupList();
                 for (const QString &rule : rules) {
                     KConfigGroup ruleGroup(&rewriteGroup, rule);
 
                     const QString propertyConfig = ruleGroup.readEntry(QStringLiteral("Property"), QString());
 
                     QString matchProperty;
                     if (propertyConfig == QLatin1String("ClassClass")) {
                         matchProperty = classClass;
                     } else if (propertyConfig == QLatin1String("ClassName")) {
                         matchProperty = className;
                     }
 
                     if (matchProperty.isEmpty()) {
                         continue;
                     }
 
                     const QString serviceSearchIdentifier = ruleGroup.readEntry(QStringLiteral("Identifier"), QString());
                     if (serviceSearchIdentifier.isEmpty()) {
                         continue;
                     }
 
                     QRegularExpression regExp(ruleGroup.readEntry(QStringLiteral("Match")));
                     const auto match = regExp.match(matchProperty);
 
                     if (match.hasMatch()) {
                         const QString actualMatch = match.captured(QStringLiteral("match"));
                         if (actualMatch.isEmpty()) {
                             continue;
                         }
 
                         const QString rewrittenString = ruleGroup.readEntry(QStringLiteral("Target")).arg(actualMatch);
 
                         services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ %2)").arg(rewrittenString, serviceSearchIdentifier));
 
                         if (!services.isEmpty()) {
                             break;
                         }
                     }
                 }
             }
 
             if (!mapped.isEmpty()) {
                 services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ DesktopEntryName)").arg(mapped));
             }
 
             if (!mapped.isEmpty() && services.empty()) {
                 services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Name)").arg(mapped));
             }
 
             // To match other docks (docky, unity, etc.) attempt to match on DesktopEntryName first ...
             if (services.empty()) {
                 services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ DesktopEntryName)").arg(classClass));
             }
 
             // Try StartupWMClass.
             if (services.empty()) {
                 services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ StartupWMClass)").arg(classClass));
             }
 
             // Try 'Name' - unfortunately this can be translated, so has a good chance of failing! (As it does for KDE's own "System Settings" (even in English!!))
             if (services.empty()) {
                 services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Name)").arg(classClass));
             }
         }
 
         // Ok, absolute *last* chance, try matching via pid (but only if we have not already tried this!) ...
         if (services.empty() && !triedPid) {
             services = servicesFromPid(pid);
         }
     }
 
     // Try to improve on a possible from-binary fallback.
     // If no services were found or we got a fake-service back from getServicesViaPid()
     // we attempt to improve on this by adding a loosely matched reverse-domain-name
     // DesktopEntryName. Namely anything that is '*.classClass.desktop' would qualify here.
     //
     // Illustrative example of a case where the above heuristics would fail to produce
     // a reasonable result:
     // - org.kde.dragonplayer.desktop
     // - binary is 'dragon'
     // - qapp appname and thus classClass is 'dragonplayer'
     // - classClass cannot directly match the desktop file because of RDN
     // - classClass also cannot match the binary because of name mismatch
     // - in the following code *.classClass can match org.kde.dragonplayer though
     if (services.empty() || services.at(0)->desktopEntryName().isEmpty()) {
         auto matchingServices = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
             QStringLiteral("exist Exec and ('%1' ~~ DesktopEntryName)").arg(classClass));
         QMutableListIterator<KService::Ptr> it(matchingServices);
         while (it.hasNext()) {
             auto service = it.next();
             if (!service->desktopEntryName().endsWith("." + classClass)) {
                 it.remove();
             }
         }
         // Exactly one match is expected, otherwise we discard the results as to reduce
         // the likelihood of false-positive mappings. Since we essentially eliminate the
         // uniqueness that RDN is meant to bring to the table we could potentially end
         // up with more than one match here.
         if (matchingServices.length() == 1) {
             services = matchingServices;
         }
     }
 
     if (!services.empty()) {
         QString path = services[0]->entryPath();
         if (path.isEmpty()) {
             path = services[0]->exec();
         }
 
         if (!path.isEmpty()) {
             url = QUrl::fromLocalFile(path);
         }
     }
 
     return url;
 }
 
-QUrl XWindowTasksModel::Private::launcherUrl(WId window)
+QUrl XWindowTasksModel::Private::launcherUrl(WId window, bool encodeFallbackIcon)
 {
     const AppData &data = appData(window);
 
-    if (!data.icon.name().isEmpty()) {
+    if (!encodeFallbackIcon || !data.icon.name().isEmpty()) {
         return data.url;
     }
 
     QUrl url = data.url;
 
     // FIXME Hard-coding 64x64 or SizeLarge is not scaling-aware.
 
     const QPixmap pixmap = KWindowSystem::icon(window, KIconLoader::SizeLarge, KIconLoader::SizeLarge, false);
     if (pixmap.isNull()) {
         return data.url;
     }
     QUrlQuery uQuery(url);
     QByteArray bytes;
     QBuffer buffer(&bytes);
     buffer.open(QIODevice::WriteOnly);
     pixmap.save(&buffer, "PNG");
     uQuery.addQueryItem(QStringLiteral("iconData"), bytes.toBase64(QByteArray::Base64UrlEncoding));
 
     url.setQuery(uQuery);
 
     return url;
 }
 
 QUrl XWindowTasksModel::Private::serviceUrl(int pid, const QString &type, const QStringList &cmdRemovals = QStringList())
 {
     if (pid == 0) {
         return QUrl();
     }
 
     KSysGuard::Processes procs;
     procs.updateOrAddProcess(pid);
 
     KSysGuard::Process *proc = procs.getProcess(pid);
     QString cmdline = proc ? proc->command().simplified() : QString(); // proc->command has a trailing space???
 
     if (cmdline.isEmpty()) {
         return QUrl();
     }
 
     foreach (const QString & r, cmdRemovals) {
         cmdline.replace(r, QLatin1String(""));
     }
 
     KService::List services = KServiceTypeTrader::self()->query(type, QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline));
 
     if (services.empty()) {
         // Could not find with complete command line, so strip out path part ...
         int slash = cmdline.lastIndexOf('/', cmdline.indexOf(' '));
         if (slash > 0) {
             services = KServiceTypeTrader::self()->query(type, QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline.mid(slash + 1)));
         }
 
         if (services.empty()) {
             return QUrl();
         }
     }
 
     if (!services.isEmpty()) {
         QString path = services[0]->entryPath();
 
         if (!QDir::isAbsolutePath(path)) {
             QString absolutePath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kservices5/"+path);
             if (!absolutePath.isEmpty())
                 path = absolutePath;
         }
 
         if (QFile::exists(path)) {
             return QUrl::fromLocalFile(path);
         }
     }
 
     return QUrl();
 }
 
 KService::List XWindowTasksModel::Private::servicesFromPid(int pid)
 {
     // Attempt to find using commandline...
     KService::List services;
 
     if (pid == 0) {
         return services;
     }
 
     KSysGuard::Processes procs;
     procs.updateOrAddProcess(pid);
 
     KSysGuard::Process *proc = procs.getProcess(pid);
     QString cmdline = proc ? proc->command().simplified() : QString(); // proc->command has a trailing space???
 
     if (cmdline.isEmpty()) {
         return services;
     }
 
     const int firstSpace = cmdline.indexOf(' ');
 
     services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline));
     if (services.empty()) {
         // Could not find with complete commandline, so strip out path part...
         int slash = cmdline.lastIndexOf('/', firstSpace);
         if (slash > 0) {
             services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline.mid(slash + 1)));
         }
     }
 
     if (services.empty() && firstSpace > 0) {
         // Could not find with arguments, so try without...
         cmdline = cmdline.left(firstSpace);
         services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline));
 
         int slash = cmdline.lastIndexOf('/');
         if (slash > 0) {
             services = KServiceTypeTrader::self()->query(QStringLiteral("Application"), QStringLiteral("exist Exec and ('%1' =~ Exec)").arg(cmdline.mid(slash + 1)));
         }
     }
 
     if (services.empty() && proc && !QStandardPaths::findExecutable(cmdline).isEmpty()) {
         // cmdline now exists without arguments if there were any
         services << QExplicitlySharedDataPointer<KService>(new KService(proc->name(), cmdline, QString()));
     }
     return services;
 }
 
 int XWindowTasksModel::Private::screen(WId window)
 {
     const KWindowInfo *info = windowInfo(window);
     const QList<QScreen *> &screens = QGuiApplication::screens();
 
     for (int i = 0; i < screens.count(); ++i) {
         if (screens.at(i)->geometry().intersects(info->geometry())) {
             return i;
         }
     }
 
     return -1;
 }
 
 QStringList XWindowTasksModel::Private::activities(WId window)
 {
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), 0, NET::WM2Activities);
 
     const QString result(ni.activities());
 
     if (!result.isEmpty() && result != QLatin1String("00000000-0000-0000-0000-000000000000")) {
         return result.split(',');
     }
 
     return QStringList();
 }
 
 bool XWindowTasksModel::Private::demandsAttention(WId window)
 {
     if (windows.contains(window)) {
         return ((windowInfo(window)->state() & NET::DemandsAttention)
         || transientsDemandingAttention.contains(window));
     }
 
     return false;
 }
 
 XWindowTasksModel::XWindowTasksModel(QObject *parent)
     : AbstractTasksModel(parent)
     , d(new Private(this))
 {
     d->init();
 }
 
 XWindowTasksModel::~XWindowTasksModel()
 {
 }
 
 QVariant XWindowTasksModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()  || index.row() >= d->windows.count()) {
         return QVariant();
     }
 
     const WId window = d->windows.at(index.row());
 
     if (role == Qt::DisplayRole) {
         return d->windowInfo(window)->visibleName();
     } else if (role == Qt::DecorationRole) {
         return d->icon(window);
     } else if (role == AppId) {
         return d->appData(window).id;
     } else if (role == AppName) {
         return d->appData(window).name;
     } else if (role == GenericName) {
         return d->appData(window).genericName;
     } else if (role == LauncherUrl) {
         return d->launcherUrl(window);
+    } else if (role == LauncherUrlWithoutIcon) {
+        return d->launcherUrl(window, false /* encodeFallbackIcon */);
     } else if (role == LegacyWinIdList) {
         return QVariantList() << window;
     } else if (role == MimeType) {
         return d->mimeType();
     } else if (role == MimeData) {
         return QByteArray((char*)&window, sizeof(window));;
     } else if (role == IsWindow) {
         return true;
     } else if (role == IsActive) {
         return (window == d->activeWindow);
     } else if (role == IsClosable) {
         return d->windowInfo(window)->actionSupported(NET::ActionClose);
     } else if (role == IsMovable) {
         return d->windowInfo(window)->actionSupported(NET::ActionMove);
     } else if (role == IsResizable) {
         return d->windowInfo(window)->actionSupported(NET::ActionResize);
     } else if (role == IsMaximizable) {
         return d->windowInfo(window)->actionSupported(NET::ActionMax);
     } else if (role == IsMaximized) {
         const KWindowInfo *info = d->windowInfo(window);
         return (bool)(info->state() & NET::MaxHoriz) && (bool)(info->state() & NET::MaxVert);
     } else if (role == IsMinimizable) {
         return d->windowInfo(window)->actionSupported(NET::ActionMinimize);
     } else if (role == IsMinimized) {
         return d->windowInfo(window)->isMinimized();
     } else if (role == IsKeepAbove) {
         return (bool)(d->windowInfo(window)->state() & NET::StaysOnTop);
     } else if (role == IsKeepBelow) {
         return (bool)(d->windowInfo(window)->state() & NET::KeepBelow);
     } else if (role == IsFullScreenable) {
         return d->windowInfo(window)->actionSupported(NET::ActionFullScreen);
     } else if (role == IsFullScreen) {
         return (bool)(d->windowInfo(window)->state() & NET::FullScreen);
     } else if (role == IsShadeable) {
         return d->windowInfo(window)->actionSupported(NET::ActionShade);
     } else if (role == IsShaded) {
         return (bool)(d->windowInfo(window)->state() & NET::Shaded);
     } else if (role == IsVirtualDesktopChangeable) {
         return d->windowInfo(window)->actionSupported(NET::ActionChangeDesktop);
     } else if (role == VirtualDesktop) {
         return d->windowInfo(window)->desktop();
     } else if (role == IsOnAllVirtualDesktops) {
         return d->windowInfo(window)->onAllDesktops();
     } else if (role == Screen) {
         return d->screen(window);
     } else if (role == Activities) {
         return d->activities(window);
     } else if (role == IsDemandingAttention) {
         return d->demandsAttention(window);
     } else if (role == SkipTaskbar) {
         return (bool)(d->windowInfo(window)->state() & NET::SkipTaskbar);
     }
 
     return QVariant();
 }
 
 int XWindowTasksModel::rowCount(const QModelIndex &parent) const
 {
     return parent.isValid() ? 0 : d->windows.count();
 }
 
 void XWindowTasksModel::requestActivate(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     if (index.row() >= 0 && index.row() < d->windows.count()) {
         WId window = d->windows.at(index.row());
 
         // Pull forward any transient demanding attention.
         if (d->transientsDemandingAttention.contains(window)) {
             window = d->transientsDemandingAttention.value(window);
         // Quote from legacy libtaskmanager:
         // "this is a work around for (at least?) kwin where a shaded transient will prevent the main
         // window from being brought forward unless the transient is actually pulled forward, most
         // easily reproduced by opening a modal file open/save dialog on an app then shading the file
         // dialog and trying to bring the window forward by clicking on it in a tasks widget
         // TODO: do we need to check all the transients for shaded?"
         } else if (!d->transients.isEmpty()) {
             foreach (const WId transient, d->transients) {
                 KWindowInfo info(transient, NET::WMState, NET::WM2TransientFor);
 
                 if (info.valid(true) && (info.state() & NET::Shaded) && info.transientFor() == window) {
                     window = transient;
                     break;
                 }
             }
         }
 
         KWindowSystem::forceActiveWindow(window);
     }
 }
 
 void XWindowTasksModel::requestNewInstance(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const QUrl &url = d->appData(d->windows.at(index.row())).url;
 
     if (url.isValid()) {
         new KRun(url, 0, false, KStartupInfo::createNewStartupIdForTimestamp(QX11Info::appUserTime()));
     }
 }
 
 void XWindowTasksModel::requestClose(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     NETRootInfo ri(QX11Info::connection(), NET::CloseWindow);
     ri.closeWindowRequest(d->windows.at(index.row()));
 }
 
 void XWindowTasksModel::requestMove(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     bool onCurrent = info->isOnCurrentDesktop();
 
     if (!onCurrent) {
         KWindowSystem::setCurrentDesktop(info->desktop());
         KWindowSystem::forceActiveWindow(window);
     }
 
     if (info->isMinimized()) {
         KWindowSystem::unminimizeWindow(window);
     }
 
     const QRect &geom = info->geometry();
 
     NETRootInfo ri(QX11Info::connection(), NET::WMMoveResize);
     ri.moveResizeRequest(window, geom.center().x(), geom.center().y(), NET::Move);
 }
 
 void XWindowTasksModel::requestResize(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     bool onCurrent = info->isOnCurrentDesktop();
 
     if (!onCurrent) {
         KWindowSystem::setCurrentDesktop(info->desktop());
         KWindowSystem::forceActiveWindow(window);
     }
 
     if (info->isMinimized()) {
         KWindowSystem::unminimizeWindow(window);
     }
 
     const QRect &geom = info->geometry();
 
     NETRootInfo ri(QX11Info::connection(), NET::WMMoveResize);
     ri.moveResizeRequest(window, geom.bottomRight().x(), geom.bottomRight().y(), NET::BottomRight);
 }
 
 void XWindowTasksModel::requestToggleMinimized(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     if (info->isMinimized()) {
         bool onCurrent = info->isOnCurrentDesktop();
 
         // FIXME: Move logic up into proxy? (See also others.)
         if (!onCurrent) {
             KWindowSystem::setCurrentDesktop(info->desktop());
         }
 
         KWindowSystem::unminimizeWindow(window);
 
         if (onCurrent) {
             KWindowSystem::forceActiveWindow(window);
         }
     } else {
         KWindowSystem::minimizeWindow(window);
     }
 }
 
 void XWindowTasksModel::requestToggleMaximized(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
     bool onCurrent = info->isOnCurrentDesktop();
     bool restore = (info->state() & NET::MaxHoriz) && (bool)(info->state() & NET::MaxVert);
 
     // FIXME: Move logic up into proxy? (See also others.)
     if (!onCurrent) {
         KWindowSystem::setCurrentDesktop(info->desktop());
     }
 
     if (info->isMinimized()) {
         KWindowSystem::unminimizeWindow(window);
     }
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMState, 0);
 
     if (restore) {
         ni.setState(0, NET::Max);
     } else {
         ni.setState(NET::Max, NET::Max);
     }
 
     if (!onCurrent) {
         KWindowSystem::forceActiveWindow(window);
     }
 }
 
 void XWindowTasksModel::requestToggleKeepAbove(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMState, 0);
 
     if (info->state() & NET::StaysOnTop) {
         ni.setState(0, NET::StaysOnTop);
     } else {
         ni.setState(NET::StaysOnTop, NET::StaysOnTop);
     }
 }
 
 void XWindowTasksModel::requestToggleKeepBelow(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMState, 0);
 
     if (info->state() & NET::KeepBelow) {
         ni.setState(0, NET::KeepBelow);
     } else {
         ni.setState(NET::KeepBelow, NET::KeepBelow);
     }
 }
 
 void XWindowTasksModel::requestToggleFullScreen(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMState, 0);
 
     if (info->state() & NET::FullScreen) {
         ni.setState(0, NET::FullScreen);
     } else {
         ni.setState(NET::FullScreen, NET::FullScreen);
     }
 }
 
 void XWindowTasksModel::requestToggleShaded(const QModelIndex &index)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), NET::WMState, 0);
 
     if (info->state() & NET::Shaded) {
         ni.setState(0, NET::Shaded);
     } else {
         ni.setState(NET::Shaded, NET::Shaded);
     }
 }
 
 void XWindowTasksModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop)
 {
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
     const KWindowInfo *info = d->windowInfo(window);
 
     if (desktop == 0) {
         if (info->onAllDesktops()) {
             KWindowSystem::setOnDesktop(window, KWindowSystem::currentDesktop());
             KWindowSystem::forceActiveWindow(window);
         } else {
             KWindowSystem::setOnAllDesktops(window, true);
         }
 
         return;
     // FIXME Move add-new-desktop logic up into proxy.
     } else if (desktop > KWindowSystem::numberOfDesktops()) {
         desktop = KWindowSystem::numberOfDesktops() + 1;
 
         // FIXME Arbitrary limit of 20 copied from old code.
         if (desktop > 20) {
             return;
         }
 
         NETRootInfo ri(QX11Info::connection(), NET::NumberOfDesktops);
         ri.setNumberOfDesktops(desktop);
     }
 
     KWindowSystem::setOnDesktop(window, desktop);
 
     if (desktop == KWindowSystem::currentDesktop()) {
         KWindowSystem::forceActiveWindow(window);
     }
 }
 
 void XWindowTasksModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate)
 {
     Q_UNUSED(delegate)
 
     if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->windows.count()) {
         return;
     }
 
     const WId window = d->windows.at(index.row());
 
     if (d->delegateGeometries.contains(window)
         && d->delegateGeometries.value(window) == geometry) {
         return;
     }
 
     NETWinInfo ni(QX11Info::connection(), window, QX11Info::appRootWindow(), 0, 0);
     NETRect rect;
 
     if (geometry.isValid()) {
         rect.pos.x = geometry.x();
         rect.pos.y = geometry.y();
         rect.size.width = geometry.width();
         rect.size.height = geometry.height();
 
         d->delegateGeometries.insert(window, geometry);
     } else {
         d->delegateGeometries.remove(window);
     }
 
     ni.setIconGeometry(rect);
 }
 
 }