diff --git a/applets/taskmanager/package/contents/ui/ContextMenu.qml b/applets/taskmanager/package/contents/ui/ContextMenu.qml
index 29e968592..daf55bb91 100644
--- a/applets/taskmanager/package/contents/ui/ContextMenu.qml
+++ b/applets/taskmanager/package/contents/ui/ContextMenu.qml
@@ -1,668 +1,677 @@
 /***************************************************************************
  *   Copyright (C) 2012-2016 by Eike Hein <hein@kde.org>                   *
  *   Copyright (C) 2016 by Kai Uwe Broulik <kde@privat.broulik.de>         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 import QtQuick 2.0
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 import org.kde.taskmanager 0.1 as TaskManager
 
 PlasmaComponents.ContextMenu {
     id: menu
 
     property QtObject backend
     property QtObject mpris2Source
     property var modelIndex
     readonly property var atm: TaskManager.AbstractTasksModel
 
     property bool showAllPlaces: false
 
     placement: {
         if (plasmoid.location == PlasmaCore.Types.LeftEdge) {
             return PlasmaCore.Types.RightPosedTopAlignedPopup;
         } else if (plasmoid.location == PlasmaCore.Types.TopEdge) {
             return PlasmaCore.Types.BottomPosedLeftAlignedPopup;
         } else if (plasmoid.location == PlasmaCore.Types.RightEdge) {
             return PlasmaCore.Types.LeftPosedTopAlignedPopup;
         } else {
             return PlasmaCore.Types.TopPosedLeftAlignedPopup;
         }
     }
 
     minimumWidth: visualParent.width
 
     onStatusChanged: {
         if (visualParent && get(atm.LauncherUrlWithoutIcon) != null && status == PlasmaComponents.DialogStatus.Open) {
             launcherToggleAction.checked = (tasksModel.launcherPosition(get(atm.LauncherUrlWithoutIcon)) != -1);
             activitiesDesktopsMenu.refresh();
 
         } else if (status == PlasmaComponents.DialogStatus.Closed) {
             menu.destroy();
             backend.ungrabMouse(visualParent);
         }
     }
 
     Component.onCompleted: {
         // Cannot have "Connections" as child of PlasmaCoponents.ContextMenu.
         backend.showAllPlaces.connect(function() {
             visualParent.showContextMenu({showAllPlaces: true});
         });
     }
 
     function get(modelProp) {
         return tasksModel.data(modelIndex, modelProp)
     }
 
     function show() {
         loadDynamicLaunchActions(get(atm.LauncherUrlWithoutIcon));
         openRelative();
     }
 
     function newMenuItem(parent) {
         return Qt.createQmlObject(
             "import org.kde.plasma.components 2.0 as PlasmaComponents;" +
             "PlasmaComponents.MenuItem {}",
             parent);
     }
 
     function newSeparator(parent) {
         return Qt.createQmlObject(
             "import org.kde.plasma.components 2.0 as PlasmaComponents;" +
             "PlasmaComponents.MenuItem { separator: true }",
             parent);
     }
 
     function loadDynamicLaunchActions(launcherUrl) {
         var lists = [
             backend.jumpListActions(launcherUrl, menu),
             backend.placesActions(launcherUrl, showAllPlaces, menu),
             backend.recentDocumentActions(launcherUrl, menu)
         ]
 
         lists.forEach(function (list) {
             for (var i = 0; i < list.length; ++i) {
                 var item = newMenuItem(menu);
                 item.action = list[i];
                 menu.addMenuItem(item, virtualDesktopsMenuItem);
             }
 
             if (list.length > 0) {
                 menu.addMenuItem(newSeparator(menu), virtualDesktopsMenuItem);
             }
         });
 
         // Add Media Player control actions
         var sourceName = mpris2Source.sourceNameForLauncherUrl(launcherUrl, get(atm.AppPid));
 
         if (sourceName && !(get(atm.LegacyWinIdList) != undefined && get(atm.LegacyWinIdList).length > 1)) {
             var playerData = mpris2Source.data[sourceName]
 
             if (playerData.CanControl) {
+                var playing = (playerData.PlaybackStatus === "Playing");
                 var menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Play previous track", "Previous Track");
                 menuItem.icon = "media-skip-backward";
                 menuItem.enabled = Qt.binding(function() {
                     return playerData.CanGoPrevious;
                 });
                 menuItem.clicked.connect(function() {
                     mpris2Source.goPrevious(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 // PlasmaCore Menu doesn't actually handle icons or labels changing at runtime...
                 menuItem.text = Qt.binding(function() {
-                    return playerData.PlaybackStatus === "Playing" ? i18nc("Pause playback", "Pause") : i18nc("Start playback", "Play");
+                    // if CanPause, toggle the menu entry between Play & Pause, otherwise always use Play
+                    return playing && playerData.CanPause ? i18nc("Pause playback", "Pause") : i18nc("Start playback", "Play");
                 });
                 menuItem.icon = Qt.binding(function() {
-                    return playerData.PlaybackStatus === "Playing" ? "media-playback-pause" : "media-playback-start";
+                    return playing && playerData.CanPause ? "media-playback-pause" : "media-playback-start";
                 });
                 menuItem.enabled = Qt.binding(function() {
-                    return playerData.PlaybackStatus === "Playing" ? playerData.CanPause : playerData.CanPlay;
+                    return playing ? playerData.CanPause : playerData.CanPlay;
                 });
                 menuItem.clicked.connect(function() {
-                    mpris2Source.playPause(sourceName);
+                    if (playing) {
+                        mpris2Source.pause(sourceName);
+                    } else {
+                        mpris2Source.play(sourceName);
+                    }
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Play next track", "Next Track");
                 menuItem.icon = "media-skip-forward";
                 menuItem.enabled = Qt.binding(function() {
                     return playerData.CanGoNext;
                 });
                 menuItem.clicked.connect(function() {
                     mpris2Source.goNext(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Stop playback", "Stop");
                 menuItem.icon = "media-playback-stop";
+                menuItem.enabled = Qt.binding(function() {
+                    return playerData.PlaybackStatus !== "Stopped";
+                });
                 menuItem.clicked.connect(function() {
                     mpris2Source.stop(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 // Technically media controls and audio streams are separate but for the user they're
                 // semantically related, don't add a separator inbetween.
                 if (!menu.visualParent.hasAudioStream) {
                     menu.addMenuItem(newSeparator(menu), virtualDesktopsMenuItem);
                 }
 
                 // If we don't have a window associated with the player but we can quit
                 // it through MPRIS we'll offer a "Quit" option instead of "Close"
                 if (!closeWindowItem.visible && playerData.CanQuit) {
                     menuItem = menu.newMenuItem(menu);
                     menuItem.text = i18nc("Quit media player app", "Quit");
                     menuItem.icon = "application-exit";
                     menuItem.visible = Qt.binding(function() {
                         return !closeWindowItem.visible;
                     });
                     menuItem.clicked.connect(function() {
                         mpris2Source.quit(sourceName);
                     });
                     menu.addMenuItem(menuItem);
                 }
 
                 // If we don't have a window associated with the player but we can raise
                 // it through MPRIS we'll offer a "Restore" option
                 if (!startNewInstanceItem.visible && playerData.CanRaise) {
                     menuItem = menu.newMenuItem(menu);
                     menuItem.text = i18nc("Open or bring to the front window of media player app", "Restore");
                     menuItem.icon = playerData["Desktop Icon Name"];
                     menuItem.visible = Qt.binding(function() {
                         return !startNewInstanceItem.visible;
                     });
                     menuItem.clicked.connect(function() {
                         mpris2Source.raise(sourceName);
                     });
                     menu.addMenuItem(menuItem, startNewInstanceItem);
                 }
             }
         }
 
         // We allow mute/unmute whenever an application has a stream, regardless of whether it
         // is actually playing sound.
         // This way you can unmute, e.g. a telephony app, even after the conversation has ended,
         // so you still have it ringing later on.
         if (menu.visualParent.hasAudioStream) {
             var muteItem = menu.newMenuItem(menu);
             muteItem.checkable = true;
             muteItem.checked = Qt.binding(function() {
                 return menu.visualParent && menu.visualParent.muted;
             });
             muteItem.clicked.connect(function() {
                 menu.visualParent.toggleMuted();
             });
             muteItem.text = i18n("Mute");
             muteItem.icon = "audio-volume-muted";
             menu.addMenuItem(muteItem, virtualDesktopsMenuItem);
 
             menu.addMenuItem(newSeparator(menu), virtualDesktopsMenuItem);
         }
     }
 
     PlasmaComponents.MenuItem {
         id: virtualDesktopsMenuItem
 
         visible: virtualDesktopInfo.numberOfDesktops > 1
             && (visualParent && get(atm.IsLauncher) !== true
             && get(atm.IsStartup) !== true
             && get(atm.IsVirtualDesktopChangeable) === true)
 
         enabled: visible
 
         text: i18n("Move To &Desktop")
 
         Connections {
             target: virtualDesktopInfo
 
             onNumberOfDesktopsChanged: virtualDesktopsMenu.refresh()
             onDesktopNamesChanged: virtualDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: virtualDesktopsMenu
 
             visualParent: virtualDesktopsMenuItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (virtualDesktopInfo.numberOfDesktops <= 1) {
                     return;
                 }
 
                 var menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("Move &To Current Desktop");
                 menuItem.enabled = Qt.binding(function() {
                     return menu.visualParent && menu.get(atm.VirtualDesktop) != virtualDesktopInfo.currentDesktop;
                 });
                 menuItem.clicked.connect(function() {
                     tasksModel.requestVirtualDesktop(menu.modelIndex, virtualDesktopInfo.currentDesktop);
                 });
 
                 menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("&All Desktops");
                 menuItem.checkable = true;
                 menuItem.checked = Qt.binding(function() {
                     return menu.visualParent && menu.get(atm.IsOnAllVirtualDesktops) === true;
                 });
                 menuItem.clicked.connect(function() {
                     tasksModel.requestVirtualDesktop(menu.modelIndex, 0);
                 });
                 backend.setActionGroup(menuItem.action);
 
                 menu.newSeparator(virtualDesktopsMenu);
 
                 for (var i = 0; i < virtualDesktopInfo.desktopNames.length; ++i) {
                     menuItem = menu.newMenuItem(virtualDesktopsMenu);
                     menuItem.text = i18nc("1 = number of desktop, 2 = desktop name", "&%1 %2", i + 1, virtualDesktopInfo.desktopNames[i]);
                     menuItem.checkable = true;
                     menuItem.checked = Qt.binding((function(i) {
                         return function() { return menu.visualParent && menu.get(atm.VirtualDesktop) == (i + 1) };
                     })(i));
                     menuItem.clicked.connect((function(i) {
                         return function() { return tasksModel.requestVirtualDesktop(menu.modelIndex, i + 1); };
                     })(i));
                     backend.setActionGroup(menuItem.action);
                 }
 
                 menu.newSeparator(virtualDesktopsMenu);
 
                 menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("&New Desktop");
                 menuItem.clicked.connect(function() {
                     tasksModel.requestVirtualDesktop(menu.modelIndex, virtualDesktopInfo.numberOfDesktops + 1)
                 });
             }
 
             Component.onCompleted: refresh()
         }
     }
 
      PlasmaComponents.MenuItem {
         id: activitiesDesktopsMenuItem
 
         visible: activityInfo.numberOfRunningActivities > 1
             && (visualParent && !get(atm.IsLauncher)
             && !get(atm.IsStartup))
 
         enabled: visible
 
         text: i18n("Move To &Activity")
 
         Connections {
             target: activityInfo
 
             onNumberOfRunningActivitiesChanged: activitiesDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: activitiesDesktopsMenu
 
             visualParent: activitiesDesktopsMenuItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (activityInfo.numberOfRunningActivities <= 1) {
                     return;
                 }
 
                 var menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                 menuItem.text = i18n("Add To Current Activity");
                 menuItem.enabled = Qt.binding(function() {
                     return menu.visualParent && menu.get(atm.Activities).length > 0 &&
                            menu.get(atm.Activities).indexOf(activityInfo.currentActivity) < 0;
                 });
                 menuItem.clicked.connect(function() {
                     tasksModel.requestActivities(menu.modelIndex, menu.get(atm.Activities).concat(activityInfo.currentActivity));
                 });
 
                 menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                 menuItem.text = i18n("All Activities");
                 menuItem.checkable = true;
                 menuItem.checked = Qt.binding(function() {
                     return menu.visualParent && menu.get(atm.Activities).length === 0;
                 });
                 menuItem.toggled.connect(function(checked) {
                     var newActivities = undefined; // will cast to an empty QStringList i.e all activities
                     if (!checked) {
                         newActivities = new Array(activityInfo.currentActivity);
                     }
                     tasksModel.requestActivities(menu.modelIndex, newActivities);
                 });
 
                 menu.newSeparator(activitiesDesktopsMenu);
 
                 var runningActivities = activityInfo.runningActivities();
                 for (var i = 0; i < runningActivities.length; ++i) {
                     var activityId = runningActivities[i];
 
                     menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                     menuItem.text = activityInfo.activityName(runningActivities[i]);
                     menuItem.checkable = true;
                     menuItem.checked = Qt.binding( (function(activityId) {
                         return function() {
                             return menu.visualParent && menu.get(atm.Activities).indexOf(activityId) >= 0;
                         };
                     })(activityId));
                     menuItem.toggled.connect((function(activityId) {
                         return function (checked) {
                             var newActivities = menu.get(atm.Activities);
                             if (checked) {
                                 newActivities = newActivities.concat(activityId);
                             } else {
                                 var index = newActivities.indexOf(activityId)
                                 if (index < 0) {
                                     return;
                                 }
 
                                 newActivities.splice(index, 1);
                             }
                             return tasksModel.requestActivities(menu.modelIndex, newActivities);
                         };
                     })(activityId));
                 }
 
                 menu.newSeparator(activitiesDesktopsMenu);
             }
 
             Component.onCompleted: refresh()
         }
     }
 
 
     PlasmaComponents.MenuItem {
         visible: (visualParent && get(atm.IsLauncher) !== true && get(atm.IsStartup) !== true)
 
         enabled: visualParent && get(atm.IsMinimizable) === true
 
         checkable: true
         checked: visualParent && get(atm.IsMinimized) === true
 
         text: i18n("Mi&nimize")
 
         onClicked: tasksModel.requestToggleMinimized(modelIndex)
     }
 
     PlasmaComponents.MenuItem {
         visible: (visualParent && get(atm.IsLauncher) !== true && get(atm.IsStartup) !== true)
 
         enabled: visualParent && get(atm.IsMaximizable) === true
 
         checkable: true
         checked: visualParent && get(atm.IsMaximized) === true
 
         text: i18n("Ma&ximize")
 
         onClicked: tasksModel.requestToggleMaximized(modelIndex)
     }
 
     PlasmaComponents.MenuItem {
         id: startNewInstanceItem
         visible: (visualParent && get(atm.IsLauncher) !== true && get(atm.IsStartup) !== true)
 
         enabled: visualParent && get(atm.LauncherUrlWithoutIcon) != null
 
         text: i18n("Start New Instance")
         icon: "system-run"
 
         onClicked: tasksModel.requestNewInstance(modelIndex)
     }
 
     PlasmaComponents.MenuItem {
         id: launcherToggleAction
 
         visible: visualParent
                      && get(atm.IsLauncher) !== true
                      && get(atm.IsStartup) !== true
                      && plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
                      && (activityInfo.numberOfRunningActivities < 2)
 
         enabled: visualParent && get(atm.LauncherUrlWithoutIcon) != ""
 
         checkable: true
 
         text: i18nc("Toggle action for showing a launcher button while the application is not running", "&Pin")
 
         onClicked: {
             if (tasksModel.launcherPosition(get(atm.LauncherUrlWithoutIcon)) != -1) {
                 tasksModel.requestRemoveLauncher(get(atm.LauncherUrlWithoutIcon));
             } else {
                 tasksModel.requestAddLauncher(get(atm.LauncherUrl));
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         id: showLauncherInActivitiesItem
 
         text: i18n("&Pin")
 
         visible: visualParent
                      && get(atm.IsLauncher) !== true
                      && get(atm.IsStartup) !== true
                      && plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
                      && (activityInfo.numberOfRunningActivities >= 2)
 
         Connections {
             target: activityInfo
             onNumberOfRunningActivitiesChanged: activitiesDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: activitiesLaunchersMenu
             visualParent: showLauncherInActivitiesItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (menu.visualParent === null) return;
 
                 var createNewItem = function(id, title, url, activities) {
                     var result = menu.newMenuItem(activitiesLaunchersMenu);
                     result.text = title;
 
                     result.visible = true;
                     result.checkable = true;
 
                     result.checked = activities.some(function(activity) { return activity === id });
 
                     result.clicked.connect(
                         function() {
                             if (result.checked) {
                                 tasksModel.requestAddLauncherToActivity(url, id);
                             } else {
                                 tasksModel.requestRemoveLauncherFromActivity(url, id);
                             }
                         }
                     );
 
                     return result;
                 }
 
                 if (menu.visualParent === null) return;
 
                 var url = menu.get(atm.LauncherUrlWithoutIcon);
 
                 var activities = tasksModel.launcherActivities(url);
 
                 var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
                 createNewItem(NULL_UUID, i18n("On All Activities"), url, activities);
 
                 if (activityInfo.numberOfRunningActivities <= 1) {
                     return;
                 }
 
                 createNewItem(activityInfo.currentActivity, i18n("On The Current Activity"), url, activities);
 
                 menu.newSeparator(activitiesLaunchersMenu);
 
                 var runningActivities = activityInfo.runningActivities();
 
                 runningActivities.forEach(function(id) {
                     createNewItem(id, activityInfo.activityName(id), url, activities);
                 });
             }
 
             Component.onCompleted: {
                 menu.onVisualParentChanged.connect(refresh);
                 refresh();
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         visible: (visualParent && get(atm.IsLauncher) === true) && plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
 
         text: i18nc("Remove launcher button for application shown while it is not running", "Unpin")
 
         onClicked: {
             tasksModel.requestRemoveLauncher(get(atm.LauncherUrlWithoutIcon));
         }
     }
 
 
     PlasmaComponents.MenuItem {
         id: moreActionsMenuItem
 
         visible: (visualParent && get(atm.IsLauncher) !== true && get(atm.IsStartup) !== true)
 
         enabled: visible
 
         text: i18n("More Actions")
 
         PlasmaComponents.ContextMenu {
             visualParent: moreActionsMenuItem.action
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.get(atm.IsMovable) === true
 
                 text: i18n("&Move")
                 icon: "transform-move"
 
                 onClicked: tasksModel.requestMove(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.get(atm.IsResizable) === true
 
                 text: i18n("Re&size")
 
                 onClicked: tasksModel.requestResize(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 checkable: true
                 checked: menu.visualParent && menu.get(atm.IsKeepAbove) === true
 
                 text: i18n("Keep &Above Others")
                 icon: "go-up"
 
                 onClicked: tasksModel.requestToggleKeepAbove(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 checkable: true
                 checked: menu.visualParent && menu.get(atm.IsKeepBelow) === true
 
                 text: i18n("Keep &Below Others")
                 icon: "go-down"
 
                 onClicked: tasksModel.requestToggleKeepBelow(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.get(atm.IsFullScreenable) === true
 
                 checkable: true
                 checked: menu.visualParent && menu.get(atm.IsFullScreen) === true
 
                 text: i18n("&Fullscreen")
                 icon: "view-fullscreen"
 
                 onClicked: tasksModel.requestToggleFullScreen(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.get(atm.IsShadeable) === true
 
                 checkable: true
                 checked: menu.visualParent && menu.get(atm.IsShaded) === true
 
                 text: i18n("&Shade")
 
                 onClicked: tasksModel.requestToggleShaded(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 separator: true
             }
 
             PlasmaComponents.MenuItem {
                 visible: (plasmoid.configuration.groupingStrategy != 0) && menu.get(atm.IsWindow) === true
 
                 checkable: true
                 checked: menu.visualParent && menu.get(atm.IsGroupable) === true
 
                 text: i18n("Allow this program to be grouped")
 
                 onClicked: tasksModel.requestToggleGrouping(menu.modelIndex)
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         property QtObject configureAction: null
 
         enabled: configureAction && configureAction.enabled
         visible: configureAction && configureAction.visible
 
         text: configureAction ? configureAction.text : ""
         icon: configureAction ? configureAction.icon : ""
 
         onClicked: configureAction.trigger()
 
         Component.onCompleted: configureAction = plasmoid.action("configure")
     }
 
     PlasmaComponents.MenuItem {
         separator: true
     }
 
     PlasmaComponents.MenuItem {
         id: closeWindowItem
         visible: (visualParent && get(atm.IsLauncher) !== true && get(atm.IsStartup) !== true)
 
         enabled: visualParent && get(atm.IsClosable) === true
 
         text: i18n("&Close")
         icon: "window-close"
 
         onClicked: tasksModel.requestClose(modelIndex)
     }
 }
diff --git a/applets/taskmanager/package/contents/ui/ToolTipInstance.qml b/applets/taskmanager/package/contents/ui/ToolTipInstance.qml
index 7c3a8fa07..f43ecd327 100644
--- a/applets/taskmanager/package/contents/ui/ToolTipInstance.qml
+++ b/applets/taskmanager/package/contents/ui/ToolTipInstance.qml
@@ -1,477 +1,487 @@
 /*
 *   Copyright 2013 by Sebastian Kügler <sebas@kde.org>
 *   Copyright 2014 by Martin Gräßlin <mgraesslin@kde.org>
 *   Copyright 2016 by Kai Uwe Broulik <kde@privat.broulik.de>
 *   Copyright 2017 by Roman Gilg <subdiff@gmail.com>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Library General Public License for more details
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  2.010-1301, USA.
 */
 
 import QtQuick 2.6
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 import QtQml.Models 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlsAddons
 
 import org.kde.taskmanager 0.1 as TaskManager
 
 Column {
     readonly property var submodelIndex: tasksModel.makeModelIndex(parentIndex, isGroup ? index : -1)
     readonly property int flatIndex: isGroup && index != undefined ? index : 0
 
     spacing: units.smallSpacing
 
     readonly property string mprisSourceName: mpris2Source.sourceNameForLauncherUrl(toolTipDelegate.launcherUrl, isGroup ? AppPid : pidParent)
     readonly property var playerData: mprisSourceName != "" ? mpris2Source.data[mprisSourceName] : 0
     readonly property bool hasPlayer: !!mprisSourceName && !!playerData
     readonly property bool playing: hasPlayer && playerData.PlaybackStatus === "Playing"
     readonly property bool canControl: hasPlayer && playerData.CanControl
+    readonly property bool canPlay: hasPlayer && playerData.CanPlay
+    readonly property bool canPause: hasPlayer && playerData.CanPause
     readonly property bool canGoBack: hasPlayer && playerData.CanGoPrevious
     readonly property bool canGoNext: hasPlayer && playerData.CanGoNext
     readonly property bool canRaise: hasPlayer && playerData.CanRaise
     readonly property var currentMetadata: hasPlayer ? playerData.Metadata : ({})
 
     readonly property string track: {
         var xesamTitle = currentMetadata["xesam:title"]
         if (xesamTitle) {
             return xesamTitle;
         }
         // if no track title is given, print out the file name
         var xesamUrl = currentMetadata["xesam:url"] ? currentMetadata["xesam:url"].toString() : ""
         if (!xesamUrl) {
             return "";
         }
         var lastSlashPos = xesamUrl.lastIndexOf('/')
         if (lastSlashPos < 0) {
             return "";
         }
         var lastUrlPart = xesamUrl.substring(lastSlashPos + 1)
         return decodeURIComponent(lastUrlPart);
     }
     readonly property string artist: currentMetadata["xesam:artist"] || ""
     readonly property string albumArt: currentMetadata["mpris:artUrl"] || ""
 
     //
     // launcher icon + text labels + close button
     RowLayout {
         id: header
         Layout.minimumWidth: childrenRect.width
         Layout.maximumWidth: Layout.minimumWidth
 
         Layout.minimumHeight: childrenRect.height
         Layout.maximumHeight: Layout.minimumHeight
 
         anchors.horizontalCenter: parent.horizontalCenter
 
         // launcher icon
         PlasmaCore.IconItem {
             Layout.preferredWidth: units.iconSizes.medium
             Layout.preferredHeight: units.iconSizes.medium
             source: !isWin ? icon : ""
             animated: false
             usesPlasmaTheme: false
             visible: !isWin
         }
         // all textlabels
         Column {
             PlasmaExtras.Heading {
                 level: 3
                 width: isWin ? textWidth : undefined
                 height: undefined
                 maximumLineCount: 1
                 elide: Text.ElideRight
                 text: appName
                 opacity: flatIndex == 0
                 textFormat: Text.PlainText
                 visible: text !== ""
             }
             // window title
             PlasmaExtras.Heading {
                 level: 5
                 width: isWin ? textWidth : undefined
                 height: undefined
                 maximumLineCount: 1
                 elide: Text.ElideRight
                 text: generateTitle()
                 textFormat: Text.PlainText
                 opacity: 0.75
             }
             // subtext
             PlasmaExtras.Heading {
                 level: 6
                 width: isWin ? textWidth : undefined
                 height: undefined
                 maximumLineCount: 1
                 elide: Text.ElideRight
                 text: isWin ? generateSubText() : ""
                 textFormat: Text.PlainText
                 opacity: 0.6
                 visible: text !== ""
             }
         }
 
         // Count badge.
         Badge {
             Layout.alignment: Qt.AlignRight | Qt.AlignTop
             height: units.iconSizes.smallMedium
             visible: flatIndex === 0 && smartLauncherCountVisible
             number: smartLauncherCount
         }
 
         // close button
         MouseArea {
             Layout.alignment: Qt.AlignRight | Qt.AlignTop
 
             height: units.iconSizes.smallMedium
             width: height
 
             visible: isWin
 
             acceptedButtons: Qt.LeftButton
             hoverEnabled: true
             onClicked: {
                 backend.cancelHighlightWindows();
                 tasksModel.requestClose(submodelIndex);
             }
 
             PlasmaCore.IconItem {
                 anchors.fill: parent
                 active: parent.containsMouse
 
                 source: "window-close"
                 animated: false
             }
         }
     }
 
     // thumbnail container
     Item {
         id: thumbnail
         width: header.width
         // similar to 0.5625 = 1 / (16:9) as most screens are
         // round necessary, otherwise shadow mask for players has gap!
         height: Math.round(0.5 * width)
         anchors.horizontalCenter: parent.horizontalCenter
 
         visible: isWin
 
         Item {
             id: thumbnailSourceItem
             anchors.fill: parent
 
             readonly property bool isMinimized: isGroup ? IsMinimized == true : isMinimizedParent
             // TODO: this causes XCB error message when being visible the first time
             property int winId: isWin && windows[flatIndex] != undefined ? windows[flatIndex] : 0
 
             PlasmaCore.WindowThumbnail {
                 anchors.fill: parent
 
                 visible: !albumArtImage.visible && !thumbnailSourceItem.isMinimized
                 winId: thumbnailSourceItem.winId
 
                 ToolTipWindowMouseArea {
                     anchors.fill: parent
                     rootTask: parentTask
                     modelIndex: submodelIndex
                     winId: thumbnailSourceItem.winId
                 }
             }
 
             Image {
                 id: albumArtImage
                 // also Image.Loading to prevent loading thumbnails just because the album art takes a split second to load
                 readonly property bool available: status === Image.Ready || status === Image.Loading
 
                 anchors.fill: parent
                 sourceSize: Qt.size(parent.width, parent.height)
                 asynchronous: true
                 source: albumArt
                 fillMode: Image.PreserveAspectCrop
                 visible: available
 
                 ToolTipWindowMouseArea {
                     anchors.fill: parent
                     rootTask: parentTask
                     modelIndex: submodelIndex
                     winId: thumbnailSourceItem.winId
                 }
             }
 
             // when minimized, we don't have a preview, so show the icon
             PlasmaCore.IconItem {
                 anchors.fill: parent
                 source: thumbnailSourceItem.isMinimized && !albumArtImage.visible ? icon : ""
                 animated: false
                 usesPlasmaTheme: false
                 visible: valid
 
                 ToolTipWindowMouseArea {
                     anchors.fill: parent
                     rootTask: parentTask
                     modelIndex: submodelIndex
                     winId: thumbnailSourceItem.winId
                 }
             }
         }
 
 
         Loader {
             anchors.fill: thumbnail
             sourceComponent: hasPlayer ? playerControlsComp : undefined
         }
 
         Component {
             id: playerControlsComp
 
             Item {
                 anchors.fill: parent
 
                 // TODO: When could this really be the case? A not-launcher-task always has a window!?
                 // if there's no window associated with this task, we might still be able to raise the player
 //                MouseArea {
 //                    id: raisePlayerArea
 //                    anchors.fill: parent
 
 //                    visible: !isWin || !windows[0] && canRaise
 //                    onClicked: mpris2Source.raise(mprisSourceName)
 //                }
 
                 Item {
                     id: playerControlsFrostedGlass
                     anchors.fill: parent
                     visible: false // OpacityMask would render it
 
                     Rectangle {
                         width: parent.width
                         height: parent.height - playerControlsRow.height
                         opacity: 0
                     }
 
                     Rectangle {
                         anchors.bottom: parent.bottom
                         width: parent.width
                         height: playerControlsRow.height
                         color: theme.backgroundColor
                         opacity: 0.8
                     }
                 }
 
                 OpacityMask {
                     id: playerControlsOpacityMask
                     anchors.fill: parent
                     source: playerControlsFrostedGlass
                     maskSource: thumbnailSourceItem
                 }
 
                 // prevent accidental click-through when a control is disabled
                 MouseArea {
                     anchors.fill: playerControlsRow
                 }
 
                 RowLayout {
                     id: playerControlsRow
                     anchors {
                         horizontalCenter: parent.horizontalCenter
                         bottom: parent.bottom
                     }
                     width: parent.width
                     spacing: 0
                     enabled: canControl
 
                     ColumnLayout {
                         Layout.fillWidth: true
                         spacing: 0
 
                         PlasmaExtras.Heading {
                             Layout.fillWidth: true
                             level: 4
                             wrapMode: Text.NoWrap
                             elide: Text.ElideRight
                             text: track || ""
                         }
 
                         PlasmaExtras.Heading {
                             Layout.fillWidth: true
                             level: 5
                             wrapMode: Text.NoWrap
                             elide: Text.ElideRight
                             text: artist || ""
                         }
                     }
 
                     MouseArea {
                         height: units.iconSizes.smallMedium
                         width: height
                         enabled: canGoBack
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
                         onClicked: mpris2Source.goPrevious(mprisSourceName)
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
                             enabled: canGoBack
                             active: parent.containsMouse
 
                             source: LayoutMirroring.enabled ? "media-skip-forward" : "media-skip-backward"
                             animated: false
                         }
                     }
 
                     MouseArea {
                         height: units.iconSizes.medium
                         width: height
+                        enabled: playing ? canPause : canPlay
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
-                        onClicked: mpris2Source.playPause(mprisSourceName)
+                        onClicked: {
+                            if (!playing) {
+                                mpris2Source.play(mprisSourceName);
+                            } else {
+                                mpris2Source.pause(mprisSourceName);
+                            }
+                        }
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
+                            enabled: playing ? canPause : canPlay
                             active: parent.containsMouse
 
                             source: playing ? "media-playback-pause" : "media-playback-start"
                             animated: false
                         }
                     }
 
                     MouseArea {
                         height: units.iconSizes.smallMedium
                         width: height
                         enabled: canGoNext
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
                         onClicked: mpris2Source.goNext(mprisSourceName)
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
                             enabled: canGoNext
                             active: parent.containsMouse
 
                             source: LayoutMirroring.enabled ? "media-skip-backward" : "media-skip-forward"
                             animated: false
                         }
                     }
                 }
             }
         }
     }
 
     function generateTitle() {
         if (!isWin) {
             return genericName != undefined ? genericName : "";
         }
 
         var text;
         if (isGroup) {
             if (model.display == undefined) {
                 return "";
             }
             text = model.display.toString();
         } else {
             text = displayParent;
         }
 
         // KWin appends increasing integers in between pointy brackets to otherwise equal window titles.
         // In this case save <#number> as counter and delete it at the end of text.
         var counter = text.match(/<\d+>\W*$/);
         text = text.replace(/\s*<\d+>\W*$/, "");
 
         // Remove appName from the end of text.
         var appNameRegex = new RegExp(appName + "$", "i");
         text = text.replace(appNameRegex, "");
         text = text.replace(/\s*(?:-|—)*\s*$/, "");
 
         // Add counter back at the end.
         if (counter != null) {
             if (text == "") {
                 text = counter;
             } else {
                 text = text + " " + counter;
             }
         }
 
         // In case the window title had only redundant informations (i.e. appName), text is now empty.
         // Add a hyphen to indicate that and avoid empty space.
         if (text == "") {
             text = "—";
         }
         return text.toString();
     }
 
     function generateSubText() {
         if (activitiesParent == undefined) {
             return "";
         }
 
         var subTextEntries = [];
 
         var vd = isGroup ? VirtualDesktop : virtualDesktopParent;
 
         if (!plasmoid.configuration.showOnlyCurrentDesktop
             && virtualDesktopInfo.numberOfDesktops > 1
             && (isGroup ? IsOnAllVirtualDesktops : isOnAllVirtualDesktopsParent) !== true
             && vd != -1
             && vd != undefined
             && virtualDesktopInfo.desktopNames[vd - 1] != undefined) {
             subTextEntries.push(i18n("On %1", virtualDesktopInfo.desktopNames[vd - 1]));
         }
 
         var act = isGroup ? Activities : activitiesParent;
         if (act == undefined) {
             return subTextEntries.join("\n");
         }
 
         if (act.length == 0 && activityInfo.numberOfRunningActivities > 1) {
             subTextEntries.push(i18nc("Which virtual desktop a window is currently on",
                 "Available on all activities"));
         } else if (act.length > 0) {
            var activityNames = [];
 
             for (var i = 0; i < act.length; i++) {
                 var activity = act[i];
                 var activityName = activityInfo.activityName(act[i]);
                 if (activityName == "") {
                     continue;
                 }
                 if (plasmoid.configuration.showOnlyCurrentActivity) {
                     if (activity != activityInfo.currentActivity) {
                         activityNames.push(activityName);
                     }
                 } else if (activity != activityInfo.currentActivity) {
                     activityNames.push(activityName);
                 }
             }
 
             if (plasmoid.configuration.showOnlyCurrentActivity) {
                 if (activityNames.length > 0) {
                     subTextEntries.push(i18nc("Activities a window is currently on (apart from the current one)",
                         "Also available on %1", activityNames.join(", ")));
                 }
             } else if (activityNames.length > 0) {
                 subTextEntries.push(i18nc("Which activities a window is currently on",
                     "Available on %1", activityNames.join(", ")));
             }
         }
 
         return subTextEntries.join("\n");
     }
 }
diff --git a/applets/taskmanager/package/contents/ui/main.qml b/applets/taskmanager/package/contents/ui/main.qml
index 99cd57ef4..f114513b3 100644
--- a/applets/taskmanager/package/contents/ui/main.qml
+++ b/applets/taskmanager/package/contents/ui/main.qml
@@ -1,485 +1,491 @@
 /***************************************************************************
  *   Copyright (C) 2012-2016 by Eike Hein <hein@kde.org>                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 import QtQuick 2.0
 import QtQuick.Layouts 1.1
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.taskmanager 0.1 as TaskManager
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import "../code/layout.js" as LayoutManager
 import "../code/tools.js" as TaskTools
 
 Item {
     id: tasks
 
     anchors.fill: parent
 
     property bool vertical: (plasmoid.formFactor == PlasmaCore.Types.Vertical)
     property bool iconsOnly: (plasmoid.pluginName == "org.kde.plasma.icontasks")
 
     property QtObject contextMenuComponent: Qt.createComponent("ContextMenu.qml");
 
     Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.userConfiguring) {
             groupDialog.visible = false;
         }
     }
 
     Layout.fillWidth: true
     Layout.fillHeight:true
     Layout.minimumWidth: tasks.vertical ? 0 : LayoutManager.preferredMinWidth()
     Layout.minimumHeight: !tasks.vertical ? 0 : LayoutManager.preferredMinHeight()
 
 //BEGIN TODO: this is not precise enough: launchers are smaller than full tasks
     Layout.preferredWidth: tasks.vertical ? units.gridUnit * 10 : ((LayoutManager.logicalTaskCount() * LayoutManager.preferredMaxWidth()) / LayoutManager.calculateStripes());
     Layout.preferredHeight: tasks.vertical ? ((LayoutManager.logicalTaskCount() * LayoutManager.preferredMaxHeight()) / LayoutManager.calculateStripes()) : units.gridUnit * 2;
 //END TODO
 
     property Item dragSource: null
 
     signal requestLayout
     signal windowsHovered(variant winIds, bool hovered)
     signal presentWindows(variant winIds)
 
     onWidthChanged: {
         taskList.width = LayoutManager.layoutWidth();
 
         if (plasmoid.configuration.forceStripes) {
             taskList.height = LayoutManager.layoutHeight();
         }
     }
 
     onHeightChanged: {
         if (plasmoid.configuration.forceStripes) {
             taskList.width = LayoutManager.layoutWidth();
         }
 
         taskList.height = LayoutManager.layoutHeight();
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             tasksModel.syncLaunchers();
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         readonly property int logicalLauncherCount: {
             if (plasmoid.configuration.separateLaunchers) {
                 return launcherCount;
             }
 
             var startupsWithLaunchers = 0;
 
             for (var i = 0; i < taskRepeater.count; ++i) {
                 var item = taskRepeater.itemAt(i);
 
                 if (item && item.m.IsStartup === true && item.m.HasLauncher === true) {
                     ++startupsWithLaunchers;
                 }
             }
 
             return launcherCount + startupsWithLaunchers;
         }
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: plasmoid.screenGeometry
         activity: activityInfo.currentActivity
 
         filterByVirtualDesktop: plasmoid.configuration.showOnlyCurrentDesktop
         filterByScreen: plasmoid.configuration.showOnlyCurrentScreen
         filterByActivity: plasmoid.configuration.showOnlyCurrentActivity
         filterNotMinimized: plasmoid.configuration.showOnlyMinimized
 
         sortMode: iconsOnly ? TaskManager.TasksModel.SortManual
             : sortModeEnumValue(plasmoid.configuration.sortingStrategy)
         launchInPlace: iconsOnly
         separateLaunchers: {
             if (!iconsOnly && !plasmoid.configuration.separateLaunchers
                 && plasmoid.configuration.sortingStrategy == 1) {
                 return false;
             }
 
             return true;
         }
 
         groupMode: iconsOnly ? TaskManager.TasksModel.GroupApplications
             : groupModeEnumValue(plasmoid.configuration.groupingStrategy)
         groupInline: !plasmoid.configuration.groupPopups
         groupingWindowTasksThreshold: (plasmoid.configuration.onlyGroupWhenFull && !iconsOnly
             ? LayoutManager.optimumCapacity(width, height) + 1 : -1)
 
         onLauncherListChanged: {
             layoutTimer.restart();
             plasmoid.configuration.launchers = launcherList;
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         function sortModeEnumValue(index) {
             switch (index) {
                 case 0:
                     return TaskManager.TasksModel.SortDisabled;
                 case 1:
                     return TaskManager.TasksModel.SortManual;
                 case 2:
                     return TaskManager.TasksModel.SortAlpha;
                 case 3:
                     return TaskManager.TasksModel.SortVirtualDesktop;
                 case 4:
                     return TaskManager.TasksModel.SortActivity;
                 default:
                     return TaskManager.TasksModel.SortDisabled;
             }
         }
 
         function groupModeEnumValue(index) {
             switch (index) {
                 case 0:
                     return TaskManager.TasksModel.GroupDisabled;
                 case 1:
                     return TaskManager.TasksModel.GroupApplications;
             }
         }
 
         Component.onCompleted: {
             launcherList = plasmoid.configuration.launchers;
             groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
             groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
 
             // Only hook up view only after the above churn is done.
             taskRepeater.model = tasksModel;
         }
     }
 
     Connections {
         target: tasksModel
 
         onActiveTaskChanged: {
             if (!plasmoid.configuration.groupPopups) {
                 return;
             }
             if (tasksModel.activeTask.parent.valid) {
                 groupDialog.activeTask = tasksModel.activeTask;
             }
         }
     }
 
     TaskManager.VirtualDesktopInfo {
         id: virtualDesktopInfo
     }
 
     TaskManager.ActivityInfo {
         id: activityInfo
     }
 
     TaskManagerApplet.Backend {
         id: backend
 
         taskManagerItem: tasks
         toolTipItem: toolTipDelegate
         groupDialog: groupDialog
         highlightWindows: plasmoid.configuration.highlightWindows
 
         onAddLauncher: {
             tasks.addLauncher(url);
         }
     }
 
     PlasmaCore.DataSource {
         id: mpris2Source
         engine: "mpris2"
         connectedSources: sources
         function sourceNameForLauncherUrl(launcherUrl, pid) {
             if (!launcherUrl || launcherUrl == "") {
                 return "";
             }
 
             // MPRIS spec explicitly mentions that "DesktopEntry" is with .desktop extension trimmed
             // Moreover, remove URL parameters, like wmClass (part after the question mark)
             var desktopFileName = launcherUrl.toString().split('/').pop().split('?')[0].replace(".desktop", "")
             if (desktopFileName.indexOf("applications:") === 0) {
                 desktopFileName = desktopFileName.substr(13)
             }
 
             for (var i = 0, length = connectedSources.length; i < length; ++i) {
                 var source = connectedSources[i];
                 // we intend to connect directly, otherwise the multiplexer steals the connection away
                 if (source === "@multiplex") {
                     continue;
                 }
 
                 var sourceData = data[source];
                 if (!sourceData || sourceData.DesktopEntry !== desktopFileName) {
                     continue;
                 }
 
                 if (pid === undefined || sourceData.InstancePid === pid) {
                     return source;
                 }
 
                 var metadata = sourceData.Metadata;
                 if (metadata) {
                     var kdePid = metadata["kde:pid"];
                     if (kdePid && pid === kdePid) {
                         return source;
                     }
                 }
             }
 
             return ""
         }
 
         function startOperation(source, op) {
             var service = serviceForSource(source)
             var operation = service.operationDescription(op)
             return service.startOperationCall(operation)
         }
 
         function goPrevious(source) {
             startOperation(source, "Previous");
         }
         function goNext(source) {
             startOperation(source, "Next");
         }
+        function play(source) {
+            startOperation(source, "Play");
+        }
+        function pause(source) {
+            startOperation(source, "Pause");
+        }
         function playPause(source) {
             startOperation(source, "PlayPause");
         }
         function stop(source) {
             startOperation(source, "Stop");
         }
         function raise(source) {
             startOperation(source, "Raise");
         }
         function quit(source) {
             startOperation(source, "Quit");
         }
     }
 
     Loader {
         id: pulseAudio
         source: "PulseAudio.qml"
         active: plasmoid.configuration.indicateAudioStreams
     }
 
     Timer {
         id: iconGeometryTimer
 
         interval: 500
         repeat: false
 
         onTriggered: {
             TaskTools.publishIconGeometries(taskList.children);
         }
     }
 
     Binding {
         target: plasmoid
         property: "status"
         value: (tasksModel.anyTaskDemandsAttention
             ? PlasmaCore.Types.NeedsAttentionStatus : PlasmaCore.Types.PassiveStatus)
     }
 
     Connections {
         target: plasmoid
 
         onLocationChanged: {
             // This is on a timer because the panel may not have
             // settled into position yet when the location prop-
             // erty updates.
             iconGeometryTimer.start();
         }
     }
 
     Connections {
         target: plasmoid.configuration
 
         onLaunchersChanged: tasksModel.launcherList = plasmoid.configuration.launchers
         onGroupingAppIdBlacklistChanged: tasksModel.groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
         onGroupingLauncherUrlBlacklistChanged: tasksModel.groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
     }
 
     TaskManagerApplet.DragHelper {
         id: dragHelper
 
         dragIconSize: units.iconSizes.medium
     }
 
     PlasmaCore.FrameSvgItem {
         id: taskFrame
 
         visible: false;
 
         imagePath: "widgets/tasks";
         prefix: "normal"
     }
 
     PlasmaCore.Svg {
         id: taskSvg
 
         imagePath: "widgets/tasks"
     }
 
     MouseHandler {
         id: mouseHandler
 
         anchors.fill: parent
 
         target: taskList
 
         onUrlsDropped: {
             // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
             var createLaunchers = urls.every(function (item) {
                 return backend.isApplication(item)
             });
 
             if (createLaunchers) {
                 urls.forEach(function (item) {
                     addLauncher(item);
                 });
                 return;
             }
 
             if (!hoveredItem) {
                 return;
             }
 
             // DeclarativeMimeData urls is a QJsonArray but requestOpenUrls expects a proper QList<QUrl>.
             var urlsList = backend.jsonArrayToUrlList(urls);
 
             // Otherwise we'll just start a new instance of the application with the URLs as argument,
             // as you probably don't expect some of your files to open in the app and others to spawn launchers.
             tasksModel.requestOpenUrls(hoveredItem.modelIndex(), urlsList);
         }
     }
 
     ToolTipDelegate {
         id: toolTipDelegate
 
         visible: false
     }
 
     TaskList {
         id: taskList
 
         anchors {
             left: parent.left
             top: parent.top
         }
 
         onWidthChanged: LayoutManager.layout(taskRepeater)
         onHeightChanged: LayoutManager.layout(taskRepeater)
 
         flow: {
             if (tasks.vertical) {
                 return plasmoid.configuration.forceStripes ? Flow.LeftToRight : Flow.TopToBottom
             }
             return plasmoid.configuration.forceStripes ? Flow.TopToBottom : Flow.LeftToRight
         }
 
         onAnimatingChanged: {
             if (!animating) {
                 TaskTools.publishIconGeometries(children);
             }
         }
 
         function layout() {
             taskList.width = LayoutManager.layoutWidth();
             taskList.height = LayoutManager.layoutHeight();
             LayoutManager.layout(taskRepeater);
         }
 
         Timer {
             id: layoutTimer
 
             interval: 0
             repeat: false
 
             onTriggered: taskList.layout()
         }
 
         Repeater {
             id: taskRepeater
 
             delegate: Task {}
             onItemAdded: taskList.layout()
             onItemRemoved: taskList.layout()
         }
     }
 
     GroupDialog { id: groupDialog }
 
     function hasLauncher(url) {
         return tasksModel.launcherPosition(url) != -1;
     }
 
     function addLauncher(url) {
         if (plasmoid.immutability !== PlasmaCore.Types.SystemImmutable) {
             tasksModel.requestAddLauncher(url);
         }
     }
 
     // This is called by plasmashell in response to a Meta+number shortcut.
     function activateTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var task = taskRepeater.itemAt(index);
         if (task) {
             TaskTools.activateTask(task.modelIndex(), task.m, null, task);
         }
     }
 
     function resetDragSource() {
         dragSource = null;
     }
 
     function createContextMenu(rootTask, modelIndex, args) {
         var initialArgs = args || {}
         initialArgs.visualParent = rootTask;
         initialArgs.modelIndex = modelIndex;
         initialArgs.mpris2Source = mpris2Source;
         initialArgs.backend = backend;
 
         return tasks.contextMenuComponent.createObject(rootTask, initialArgs);
     }
 
     Component.onCompleted: {
         tasks.requestLayout.connect(layoutTimer.restart);
         tasks.requestLayout.connect(iconGeometryTimer.restart);
         tasks.windowsHovered.connect(backend.windowsHovered);
         tasks.presentWindows.connect(backend.presentWindows);
         dragHelper.dropped.connect(resetDragSource);
     }
 }
diff --git a/containments/desktop/plugins/folder/foldermodel.cpp b/containments/desktop/plugins/folder/foldermodel.cpp
index 5ea26a505..7138fc215 100644
--- a/containments/desktop/plugins/folder/foldermodel.cpp
+++ b/containments/desktop/plugins/folder/foldermodel.cpp
@@ -1,1991 +1,1991 @@
 /***************************************************************************
  *   Copyright (C) 2006 David Faure <faure@kde.org>                        *
  *   Copyright (C) 2008 Fredrik Höglund <fredrik@kde.org>                  *
  *   Copyright (C) 2008 Rafael Fernández López <ereslibre@kde.org>           *
  *   Copyright (C) 2011 Marco Martin <mart@kde.org>                        *
  *   Copyright (C) 2014 by Eike Hein <hein@kde.org>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 #include "foldermodel.h"
 #include "itemviewadapter.h"
 #include "positioner.h"
 #include "screenmapper.h"
 
 #include <QApplication>
 #include <QClipboard>
 #include <QCollator>
 #include <QDesktopWidget>
 #include <QDrag>
 #include <QImage>
 #include <QItemSelectionModel>
 #include <QMenu>
 #include <QMimeData>
 #include <QMimeDatabase>
 #include <QPainter>
 #include <QPixmap>
 #include <QQuickItem>
 #include <QQuickWindow>
 #include <QTimer>
 #include <QLoggingCategory>
 #include <qplatformdefs.h>
 
 #include <KDirWatch>
 #include <KIO/DropJob>
 #include <KAuthorized>
 #include <KConfigGroup>
 #include <KFileCopyToMenu>
 #include <KFileItemActions>
 #include <KFileItemListProperties>
 #include <KNewFileMenu>
 #include <KIO/DeleteJob>
 #include <KIO/EmptyTrashJob>
 #include <KIO/FileUndoManager>
 #include <KIO/JobUiDelegate>
 #include <KIO/Paste>
 #include <KIO/PasteJob>
 #include <KIO/RestoreJob>
 #include <KLocalizedString>
 #include <KPropertiesDialog>
 #include <KSharedConfig>
 #include <KShell>
 
 #include <KCoreDirLister>
 #include <KDirLister>
 #include <KDesktopFile>
 #include <KDirModel>
 #include <KIO/CopyJob>
 #include <KIO/Job>
 #include <KProtocolInfo>
 #include <KRun>
 
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 #include <Plasma/Corona>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 Q_LOGGING_CATEGORY(FOLDERMODEL, "plasma.containments.desktop.folder.foldermodel")
 
 DirLister::DirLister(QObject *parent) : KDirLister(parent)
 {
 }
 
 DirLister:: ~DirLister()
 {
 }
 
 void DirLister::handleError(KIO::Job *job)
 {
     if (!autoErrorHandlingEnabled()) {
         emit error(job->errorString());
         return;
     }
 
     KDirLister::handleError(job);
 }
 
 FolderModel::FolderModel(QObject *parent) : QSortFilterProxyModel(parent),
     m_dirWatch(nullptr),
     m_dragInProgress(false),
     m_urlChangedWhileDragging(false),
     m_dropTargetPositionsCleanup(new QTimer(this)),
     m_previewGenerator(nullptr),
     m_viewAdapter(nullptr),
     m_actionCollection(this),
     m_newMenu(nullptr),
     m_fileItemActions(nullptr),
     m_usedByContainment(false),
     m_locked(true),
     m_sortMode(0),
     m_sortDesc(false),
     m_sortDirsFirst(true),
     m_parseDesktopFiles(false),
     m_previews(false),
     m_filterMode(NoFilter),
     m_filterPatternMatchAll(true),
     m_screenMapper(ScreenMapper::instance()),
     m_complete(false)
 {
     //needed to pass the job around with qml
     qmlRegisterType<KIO::DropJob>();
     DirLister *dirLister = new DirLister(this);
     dirLister->setDelayedMimeTypes(true);
     dirLister->setAutoErrorHandlingEnabled(false, nullptr);
     connect(dirLister, &DirLister::error, this, &FolderModel::dirListFailed);
     connect(dirLister, &KCoreDirLister::itemsDeleted, this, &FolderModel::evictFromIsDirCache);
 
     connect(dirLister, &KCoreDirLister::started, this, std::bind(&FolderModel::setStatus, this, Status::Listing));
 
     void (KCoreDirLister::*myCompletedSignal)() = &KCoreDirLister::completed;
     QObject::connect(dirLister, myCompletedSignal, this, [this] {
         setStatus(Status::Ready);
         emit listingCompleted();
     });
 
     void (KCoreDirLister::*myCanceledSignal)() = &KCoreDirLister::canceled;
     QObject::connect(dirLister, myCanceledSignal, this, [this] {
         setStatus(Status::Canceled);
         emit listingCanceled();
     });
 
     m_dirModel = new KDirModel(this);
     m_dirModel->setDirLister(dirLister);
     m_dirModel->setDropsAllowed(KDirModel::DropOnDirectory | KDirModel::DropOnLocalExecutable);
 
     /*
      * position dropped items at the desired target position
      * delay this via queued connection, such that the row is available and can be mapped
      * when we emit the move request
      */
     connect(this, &QAbstractItemModel::rowsInserted,
             this, [this](const QModelIndex &parent, int first, int last) {
         for (int i = first; i <= last; ++i) {
             const auto idx = index(i, 0, parent);
             const auto url = itemForIndex(idx).url();
             auto it = m_dropTargetPositions.find(url.fileName());
             if (it != m_dropTargetPositions.end()) {
                 const auto pos = it.value();
                 m_dropTargetPositions.erase(it);
                 setSortMode(-1);
                 emit move(pos.x(), pos.y(), {url});
             }
         }
     });
     /*
      * Dropped files may not actually show up as new files, e.g. when we overwrite
      * an existing file. Or files that fail to be listed by the dirLister, or...
      * To ensure we don't grow the map indefinitely, clean it up periodically.
      * The cleanup timer is (re)started whenever we modify the map. We use a quite
      * high interval of 10s. This should ensure, that we don't accidentally wipe
      * the mapping when we actually still want to use it. Since the time between
      * adding an entry in the map and it showing up in the model should be
      * small, this should rarely, if ever happen.
      */
     m_dropTargetPositionsCleanup->setInterval(10000);
     m_dropTargetPositionsCleanup->setSingleShot(true);
     connect(m_dropTargetPositionsCleanup, &QTimer::timeout, this, [this]() {
         if (!m_dropTargetPositions.isEmpty()) {
             qCDebug(FOLDERMODEL) << "clearing drop target positions after timeout:" << m_dropTargetPositions;
             m_dropTargetPositions.clear();
         }
     });
 
     m_selectionModel = new QItemSelectionModel(this, this);
     connect(m_selectionModel, &QItemSelectionModel::selectionChanged,
             this, &FolderModel::selectionChanged);
 
     setSourceModel(m_dirModel);
 
     setSortLocaleAware(true);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
     setDynamicSortFilter(true);
 
     sort(m_sortMode, m_sortDesc ? Qt::DescendingOrder : Qt::AscendingOrder);
 
     createActions();
 }
 
 FolderModel::~FolderModel()
 {
     if (m_usedByContainment) {
         // disconnect so we don't handle signals from the screen mapper when
         // removeScreen is called
         m_screenMapper->disconnect(this);
         m_screenMapper->removeScreen(m_screen, resolvedUrl());
     }
 }
 
 QHash< int, QByteArray > FolderModel::roleNames() const
 {
     return staticRoleNames();
 }
 
 QHash< int, QByteArray > FolderModel::staticRoleNames()
 {
     QHash<int, QByteArray> roleNames;
     roleNames[Qt::DisplayRole] = "display";
     roleNames[Qt::DecorationRole] = "decoration";
     roleNames[BlankRole] = "blank";
     roleNames[OverlaysRole] = "overlays";
     roleNames[SelectedRole] = "selected";
     roleNames[IsDirRole] = "isDir";
     roleNames[IsLinkRole] = "isLink";
     roleNames[IsHiddenRole] = "isHidden";
     roleNames[UrlRole] = "url";
     roleNames[LinkDestinationUrl] = "linkDestinationUrl";
     roleNames[SizeRole] = "size";
     roleNames[TypeRole] = "type";
 
     return roleNames;
 }
 
 void FolderModel::classBegin()
 {
 }
 
 void FolderModel::componentComplete()
 {
     m_complete = true;
     invalidate();
 }
 
 void FolderModel::invalidateIfComplete()
 {
     if (!m_complete) {
         return;
     }
 
     invalidate();
 }
 
 void FolderModel::invalidateFilterIfComplete()
 {
     if (!m_complete) {
         return;
     }
 
     invalidateFilter();
 }
 
 void FolderModel::newFileMenuItemCreated(const QUrl &url)
 {
     if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
         m_screenMapper->addMapping(url, m_screen, ScreenMapper::DelayedSignal);
         m_dropTargetPositions.insert(url.fileName(), m_menuPosition);
         m_menuPosition = {};
         m_dropTargetPositionsCleanup->start();
     }
 }
 
 QString FolderModel::url() const
 {
     return m_url;
 }
 
 void FolderModel::setUrl(const QString& url)
 {
     const QUrl &resolvedNewUrl = resolve(url);
 
     if (url == m_url) {
         m_dirModel->dirLister()->updateDirectory(resolvedNewUrl);
         return;
     }
 
     const auto oldUrl = resolvedUrl();
 
     beginResetModel();
     m_url = url;
     m_isDirCache.clear();
     m_dirModel->dirLister()->openUrl(resolvedNewUrl);
     clearDragImages();
     m_dragIndexes.clear();
     endResetModel();
 
     emit urlChanged();
     emit resolvedUrlChanged();
 
     m_errorString.clear();
     emit errorStringChanged();
 
     if (m_dirWatch) {
         delete m_dirWatch;
         m_dirWatch = nullptr;
     }
 
     if (resolvedNewUrl.isValid()) {
         m_dirWatch = new KDirWatch(this);
         connect(m_dirWatch, &KDirWatch::created, this, &FolderModel::iconNameChanged);
         connect(m_dirWatch, &KDirWatch::dirty, this, &FolderModel::iconNameChanged);
         m_dirWatch->addFile(resolvedNewUrl.toLocalFile() + QLatin1String("/.directory"));
     }
 
     if (m_dragInProgress) {
         m_urlChangedWhileDragging = true;
     }
 
     emit iconNameChanged();
 
     if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
         m_screenMapper->removeScreen(m_screen, oldUrl);
         m_screenMapper->addScreen(m_screen, resolvedUrl());
     }
 }
 
 QUrl FolderModel::resolvedUrl() const
 {
     return m_dirModel->dirLister()->url();
 }
 
 QUrl FolderModel::resolve(const QString& url)
 {
     QUrl resolvedUrl;
 
     if (url.startsWith(QLatin1Char('~'))) {
         resolvedUrl = QUrl::fromLocalFile(KShell::tildeExpand(url));
     } else {
         resolvedUrl = QUrl::fromUserInput(url);
     }
 
     return resolvedUrl;
 }
 
 QString FolderModel::iconName() const
 {
     const KFileItem rootItem(m_dirModel->dirLister()->url());
 
     if (!rootItem.isFinalIconKnown()) {
         rootItem.determineMimeType();
     }
 
     return rootItem.iconName();
 }
 
 FolderModel::Status FolderModel::status() const
 {
     return m_status;
 }
 
 void FolderModel::setStatus(Status status)
 {
     if (m_status != status) {
         m_status = status;
         emit statusChanged();
     }
 }
 
 QString FolderModel::errorString() const
 {
     return m_errorString;
 }
 
 bool FolderModel::dragging() const
 {
     return m_dragInProgress;
 }
 
 bool FolderModel::usedByContainment() const
 {
     return m_usedByContainment;
 }
 
 void FolderModel::setUsedByContainment(bool used)
 {
     if (m_usedByContainment != used) {
         m_usedByContainment = used;
 
         QAction *action = m_actionCollection.action(QStringLiteral("refresh"));
 
         if (action) {
             action->setText(m_usedByContainment ? i18n("&Refresh Desktop") : i18n("&Refresh View"));
             action->setIcon(m_usedByContainment ? QIcon::fromTheme(QStringLiteral("user-desktop")) : QIcon::fromTheme(QStringLiteral("view-refresh")));
         }
 
         m_screenMapper->disconnect(this);
         connect(m_screenMapper, &ScreenMapper::screensChanged, this, &FolderModel::invalidateFilterIfComplete);
         connect(m_screenMapper, &ScreenMapper::screenMappingChanged, this, &FolderModel::invalidateFilterIfComplete);
 
         emit usedByContainmentChanged();
     }
 }
 
 bool FolderModel::locked() const
 {
     return m_locked;
 }
 
 void FolderModel::setLocked(bool locked)
 {
     if (m_locked != locked) {
         m_locked = locked;
 
         emit lockedChanged();
     }
 }
 
 void FolderModel::dirListFailed(const QString& error)
 {
     m_errorString = error;
     emit errorStringChanged();
 }
 
 int FolderModel::sortMode() const
 {
     return m_sortMode;
 }
 
 void FolderModel::setSortMode(int mode)
 {
     if (m_sortMode != mode) {
         m_sortMode = mode;
 
         if (mode == -1 /* Unsorted */) {
             setDynamicSortFilter(false);
         } else {
             invalidateIfComplete();
             sort(m_sortMode, m_sortDesc ? Qt::DescendingOrder : Qt::AscendingOrder);
             setDynamicSortFilter(true);
         }
 
         emit sortModeChanged();
     }
 }
 
 bool FolderModel::sortDesc() const
 {
     return m_sortDesc;
 }
 
 void FolderModel::setSortDesc(bool desc)
 {
     if (m_sortDesc != desc) {
         m_sortDesc = desc;
 
         if (m_sortMode != -1 /* Unsorted */) {
             invalidateIfComplete();
             sort(m_sortMode, m_sortDesc ? Qt::DescendingOrder : Qt::AscendingOrder);
         }
 
         emit sortDescChanged();
     }
 }
 
 bool FolderModel::sortDirsFirst() const
 {
     return m_sortDirsFirst;
 }
 
 void FolderModel::setSortDirsFirst(bool enable)
 {
     if (m_sortDirsFirst != enable) {
         m_sortDirsFirst = enable;
 
         if (m_sortMode != -1 /* Unsorted */) {
             invalidateIfComplete();
             sort(m_sortMode, m_sortDesc ? Qt::DescendingOrder : Qt::AscendingOrder);
         }
 
         emit sortDirsFirstChanged();
     }
 }
 
 bool FolderModel::parseDesktopFiles() const
 {
     return m_parseDesktopFiles;
 }
 
 void FolderModel::setParseDesktopFiles(bool enable)
 {
     if (m_parseDesktopFiles != enable) {
         m_parseDesktopFiles = enable;
         emit parseDesktopFilesChanged();
     }
 }
 
 QObject* FolderModel::viewAdapter() const
 {
     return m_viewAdapter;
 }
 
 void FolderModel::setViewAdapter(QObject* adapter)
 {
     if (m_viewAdapter != adapter) {
         KAbstractViewAdapter *abstractViewAdapter = dynamic_cast<KAbstractViewAdapter *>(adapter);
 
         m_viewAdapter = abstractViewAdapter;
 
         if (m_viewAdapter && !m_previewGenerator) {
             m_previewGenerator = new KFilePreviewGenerator(abstractViewAdapter, this);
             m_previewGenerator->setPreviewShown(m_previews);
             m_previewGenerator->setEnabledPlugins(m_previewPlugins);
         }
 
         emit viewAdapterChanged();
     }
 }
 
 bool FolderModel::previews() const
 {
     return m_previews;
 }
 
 void FolderModel::setPreviews(bool previews)
 {
     if (m_previews != previews) {
         m_previews = previews;
 
         if (m_previewGenerator) {
             m_previewGenerator->setPreviewShown(m_previews);
         }
 
         emit previewsChanged();
     }
 }
 
 QStringList FolderModel::previewPlugins() const
 {
     return m_previewPlugins;
 }
 
 void FolderModel::setPreviewPlugins(const QStringList& previewPlugins)
 {
     if (m_previewPlugins != previewPlugins) {
         m_previewPlugins = previewPlugins;
 
         if (m_previewGenerator) {
             m_previewGenerator->setPreviewShown(false);
             m_previewGenerator->setEnabledPlugins(m_previewPlugins);
             m_previewGenerator->setPreviewShown(true);
         }
 
         emit previewPluginsChanged();
     }
 }
 
 int FolderModel::filterMode() const
 {
     return m_filterMode;
 }
 
 void FolderModel::setFilterMode(int filterMode)
 {
     if (m_filterMode != (FilterMode)filterMode) {
         m_filterMode = (FilterMode)filterMode;
 
         invalidateFilterIfComplete();
 
         emit filterModeChanged();
     }
 }
 
 QString FolderModel::filterPattern() const
 {
     return m_filterPattern;
 }
 
 void FolderModel::setFilterPattern(const QString &pattern)
 {
     if (m_filterPattern == pattern) {
         return;
     }
 
     m_filterPattern = pattern;
     m_filterPatternMatchAll = (pattern == QLatin1String("*"));
 
     const QStringList patterns = pattern.split(QLatin1Char(' '));
     m_regExps.clear();
     m_regExps.reserve(patterns.count());
 
     foreach (const QString &pattern, patterns) {
         QRegExp rx(pattern);
         rx.setPatternSyntax(QRegExp::Wildcard);
         rx.setCaseSensitivity(Qt::CaseInsensitive);
         m_regExps.append(rx);
     }
 
     invalidateFilterIfComplete();
 
     emit filterPatternChanged();
 }
 
 QStringList FolderModel::filterMimeTypes() const
 {
     return m_mimeSet.toList();
 }
 
 void FolderModel::setFilterMimeTypes(const QStringList &mimeList)
 {
     const QSet<QString> &set = QSet<QString>::fromList(mimeList);
 
     if (m_mimeSet != set) {
 
         m_mimeSet = set;
 
         invalidateFilterIfComplete();
 
         emit filterMimeTypesChanged();
     }
 }
 
 void FolderModel::setScreen(int screen)
 {
     if (m_screen == screen)
         return;
 
     m_screen = screen;
     if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
         m_screenMapper->addScreen(screen, resolvedUrl());
     }
     emit screenChanged();
 }
 
 KFileItem FolderModel::rootItem() const
 {
     return m_dirModel->dirLister()->rootItem();
 }
 
 void FolderModel::up()
 {
     const QUrl &up = KIO::upUrl(resolvedUrl());
 
     if (up.isValid()) {
         setUrl(up.toString());
     }
 }
 
 void FolderModel::cd(int row)
 {
     if (row < 0) {
         return;
     }
 
     const QModelIndex idx = index(row, 0);
     bool isDir = data(idx, IsDirRole).toBool();
 
     if (isDir) {
         const KFileItem  item = itemForIndex(idx);
         if (m_parseDesktopFiles && item.isDesktopFile()) {
             const KDesktopFile file(item.targetUrl().path());
             if (file.hasLinkType()) {
                 setUrl(file.readUrl());
             }
         }
         else {
             setUrl(item.url().toString());
         }
     }
 }
 
 void FolderModel::run(int row)
 {
     if (row < 0) {
         return;
     }
 
     KFileItem item = itemForIndex(index(row, 0));
 
     QUrl url(item.targetUrl());
 
     // FIXME TODO: This can go once we depend on a KIO w/ fe1f50caaf2.
     if (url.scheme().isEmpty()) {
         url.setScheme(QStringLiteral("file"));
     }
 
     KRun *run = new KRun(url, nullptr);
     // On desktop:/ we want to be able to run .desktop files right away,
     // otherwise ask for security reasons. We also don't use the targetUrl()
     // from above since we don't want the resolved /home/foo/Desktop URL.
     run->setShowScriptExecutionPrompt(item.url().scheme() != QLatin1String("desktop")
                                    || item.url().adjusted(QUrl::RemoveFilename).path() != QLatin1String("/"));
 }
 
 void FolderModel::runSelected()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     if (m_selectionModel->selectedIndexes().count() == 1) {
         run(m_selectionModel->selectedIndexes().constFirst().row());
         return;
     }
 
     KFileItemActions fileItemActions(this);
     KFileItemList items;
 
     foreach (const QModelIndex &index, m_selectionModel->selectedIndexes()) {
         // Skip over directories.
         if (!index.data(IsDirRole).toBool()) {
             items << itemForIndex(index);
         }
     }
 
     fileItemActions.runPreferredApplications(items, QString());
 }
 
 void FolderModel::rename(int row, const QString& name)
 {
     if (row < 0) {
         return;
     }
 
     QModelIndex idx = index(row, 0);
     m_dirModel->setData(mapToSource(idx), name, Qt::EditRole);
 }
 
 int FolderModel::fileExtensionBoundary(int row)
 {
     const QModelIndex idx = index(row, 0);
     const QString &name = data(idx, Qt::DisplayRole).toString();
 
     int boundary = name.length();
 
     if (data(idx, IsDirRole).toBool()) {
         return boundary;
     }
 
     QMimeDatabase db;
     const QString &ext = db.suffixForFileName(name);
 
     if (ext.isEmpty()) {
         boundary = name.lastIndexOf(QLatin1Char('.'));
 
         if (boundary < 1) {
             boundary = name.length();
         }
     } else {
         boundary -= ext.length() + 1;
     }
 
     return boundary;
 }
 
 bool FolderModel::hasSelection() const
 {
     return m_selectionModel->hasSelection();
 }
 
 bool FolderModel::isSelected(int row)
 {
     if (row < 0) {
         return false;
     }
 
     return m_selectionModel->isSelected(index(row, 0));
 }
 
 void FolderModel::setSelected(int row)
 {
     if (row < 0) {
         return;
     }
 
     m_selectionModel->select(index(row, 0), QItemSelectionModel::Select);
 }
 
 void FolderModel::toggleSelected(int row)
 {
     if (row < 0) {
         return;
     }
 
     m_selectionModel->select(index(row, 0), QItemSelectionModel::Toggle);
 }
 
 void FolderModel::setRangeSelected(int anchor, int to)
 {
     if (anchor < 0 || to < 0) {
         return;
     }
 
     QItemSelection selection(index(anchor, 0), index(to, 0));
     m_selectionModel->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void FolderModel::updateSelection(const QVariantList &rows, bool toggle)
 {
     QItemSelection newSelection;
 
     int iRow = -1;
 
     foreach (const QVariant &row, rows) {
         iRow = row.toInt();
 
         if (iRow < 0) {
             return;
         }
 
         const QModelIndex &idx = index(iRow, 0);
         newSelection.select(idx, idx);
     }
 
     if (toggle) {
         QItemSelection pinnedSelection = m_pinnedSelection;
         pinnedSelection.merge(newSelection, QItemSelectionModel::Toggle);
         m_selectionModel->select(pinnedSelection, QItemSelectionModel::ClearAndSelect);
     } else {
         m_selectionModel->select(newSelection, QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void FolderModel::clearSelection()
 {
     if (m_selectionModel->hasSelection()) {
         m_selectionModel->clear();
     }
 }
 
 void FolderModel::pinSelection()
 {
     m_pinnedSelection = m_selectionModel->selection();
 }
 
 void FolderModel::unpinSelection()
 {
     m_pinnedSelection = QItemSelection();
 }
 
 void FolderModel::addItemDragImage(int row, int x, int y, int width, int height, const QVariant &image)
 {
     if (row < 0) {
         return;
     }
 
     delete m_dragImages.take(row);
 
     DragImage *dragImage = new DragImage();
     dragImage->row = row;
     dragImage->rect = QRect(x, y, width, height);
     dragImage->image = image.value<QImage>();
     dragImage->blank = false;
 
     m_dragImages.insert(row, dragImage);
 }
 
 void FolderModel::clearDragImages()
 {
     if (!m_dragImages.isEmpty()) {
         foreach (DragImage *image, m_dragImages) {
             delete image;
         }
 
         m_dragImages.clear();
     }
 }
 
 void FolderModel::setDragHotSpotScrollOffset(int x, int y)
 {
     m_dragHotSpotScrollOffset.setX(x);
     m_dragHotSpotScrollOffset.setY(y);
 }
 
 QPoint FolderModel::dragCursorOffset(int row)
 {
     DragImage *image = m_dragImages.value(row);
     if (!image) {
         return QPoint(0, 0);
     }
 
     return image->cursorOffset;
 }
 
 void FolderModel::addDragImage(QDrag *drag, int x, int y)
 {
     if (!drag || m_dragImages.isEmpty()) {
         return;
     }
 
     QRegion region;
 
     foreach (DragImage *image, m_dragImages) {
         image->blank = isBlank(image->row);
         image->rect.translate(-m_dragHotSpotScrollOffset.x(), -m_dragHotSpotScrollOffset.y());
         if (!image->blank && !image->image.isNull()) {
             region = region.united(image->rect);
         }
     }
 
     QRect rect = region.boundingRect();
     QPoint offset = rect.topLeft();
     rect.translate(-offset.x(), -offset.y());
 
     QImage dragImage(rect.size(), QImage::Format_RGBA8888);
     dragImage.fill(Qt::transparent);
 
     QPainter painter(&dragImage);
 
     QPoint pos;
 
     foreach (DragImage *image, m_dragImages) {
         if (!image->blank && !image->image.isNull()) {
             pos = image->rect.translated(-offset.x(), -offset.y()).topLeft();
             image->cursorOffset.setX(pos.x() - (x - offset.x()));
             image->cursorOffset.setY(pos.y() - (y - offset.y()));
 
             painter.drawImage(pos, image->image);
         }
 
         // FIXME HACK: Operate on copy.
         image->rect.translate(m_dragHotSpotScrollOffset.x(), m_dragHotSpotScrollOffset.y());
     }
 
     drag->setPixmap(QPixmap::fromImage(dragImage));
     drag->setHotSpot(QPoint(x - offset.x(), y - offset.y()));
 }
 
 void FolderModel::dragSelected(int x, int y)
 {
     if (m_dragInProgress) {
         return;
     }
 
     m_dragInProgress = true;
     emit draggingChanged();
     m_urlChangedWhileDragging = false;
 
     // Avoid starting a drag synchronously in a mouse handler or interferes with
     // child event filtering in parent items (and thus e.g. press-and-hold hand-
     // ling in a containment).
     QMetaObject::invokeMethod(this, "dragSelectedInternal", Qt::QueuedConnection,
         Q_ARG(int, x),
         Q_ARG(int, y));
 }
 
 void FolderModel::dragSelectedInternal(int x, int y)
 {
     if (!m_viewAdapter || !m_selectionModel->hasSelection()) {
         m_dragInProgress = false;
         emit draggingChanged();
         return;
     }
 
     ItemViewAdapter *adapter = qobject_cast<ItemViewAdapter *>(m_viewAdapter);
     QQuickItem *item = qobject_cast<QQuickItem *>(adapter->adapterView());
 
     QDrag *drag = new QDrag(item);
 
     addDragImage(drag, x, y);
 
     m_dragIndexes = m_selectionModel->selectedIndexes();
 
     qSort(m_dragIndexes.begin(), m_dragIndexes.end());
 
     // TODO: Optimize to emit contiguous groups.
     emit dataChanged(m_dragIndexes.first(), m_dragIndexes.last(), QVector<int>() << BlankRole);
 
     QModelIndexList sourceDragIndexes;
     sourceDragIndexes.reserve(m_dragIndexes.count());
     foreach (const QModelIndex &index, m_dragIndexes) {
         sourceDragIndexes.append(mapToSource(index));
     }
 
     drag->setMimeData(m_dirModel->mimeData(sourceDragIndexes));
 
     // Due to spring-loading (aka auto-expand), the URL might change
     // while the drag is in-flight - in that case we don't want to
     // unnecessarily emit dataChanged() for (possibly invalid) indices
     // after it ends.
     const QUrl currentUrl(m_dirModel->dirLister()->url());
 
     item->grabMouse();
     drag->exec(supportedDragActions());
 
     item->ungrabMouse();
 
     m_dragInProgress = false;
     emit draggingChanged();
     m_urlChangedWhileDragging = false;
 
     if (m_dirModel->dirLister()->url() == currentUrl) {
         const QModelIndex first(m_dragIndexes.first());
         const QModelIndex last(m_dragIndexes.last());
         m_dragIndexes.clear();
         // TODO: Optimize to emit contiguous groups.
         emit dataChanged(first, last, QVector<int>() << BlankRole);
     }
 }
 
 static bool isDropBetweenSharedViews(const QList<QUrl> &urls, const QUrl &folderUrl)
 {
     for (const auto &url : urls) {
-        if (folderUrl != url.adjusted(QUrl::RemoveFilename)) {
+        if (folderUrl != url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash)) {
             return false;
         }
     }
     return true;
 }
 
 void FolderModel::drop(QQuickItem *target, QObject* dropEvent, int row)
 {
     QMimeData *mimeData = qobject_cast<QMimeData *>(dropEvent->property("mimeData").value<QObject *>());
 
     if (!mimeData) {
         return;
     }
 
     QModelIndex idx;
     KFileItem item;
 
     if (row > -1 && row < rowCount()) {
          idx = index(row, 0);
          item = itemForIndex(idx);
     }
 
     QUrl dropTargetUrl;
 
     // So we get to run mostLocalUrl() over the current URL.
     if (item.isNull()) {
         item = rootItem();
     }
 
     if (item.isNull()) {
         dropTargetUrl = m_dirModel->dirLister()->url();
     } else if (m_parseDesktopFiles && item.isDesktopFile()) {
         const KDesktopFile file(item.targetUrl().path());
 
         if (file.hasLinkType()) {
             dropTargetUrl = QUrl(file.readUrl());
         } else {
             dropTargetUrl = item.mostLocalUrl();
         }
     } else {
         dropTargetUrl = item.mostLocalUrl();
     }
 
     auto dropTargetFolderUrl = dropTargetUrl;
     if (dropTargetFolderUrl.fileName() == QLatin1String(".")) {
         // the target URL for desktop:/ is e.g. 'file://home/user/Desktop/.'
         dropTargetFolderUrl = dropTargetFolderUrl.adjusted(QUrl::RemoveFilename);
     }
 
     // use dropTargetUrl to resolve desktop:/ to the actual file location which is also used by the mime data
     /* QMimeData operates on local URLs, but the dir lister and thus screen mapper and positioner may
      * use a fancy scheme like desktop:/ instead. Ensure we always use the latter to properly map URLs,
      * i.e. go from file:///home/user/Desktop/file to desktop:/file
      */
     auto mappableUrl = [this, dropTargetFolderUrl](const QUrl &url) -> QUrl {
         if (dropTargetFolderUrl != m_dirModel->dirLister()->url()) {
             QString mappedUrl = url.toString();
             const auto local = dropTargetFolderUrl.toString();
             const auto internal = m_dirModel->dirLister()->url().toString();
             if (mappedUrl.startsWith(local)) {
                 mappedUrl.replace(0, local.size(), internal);
             }
             return ScreenMapper::stringToUrl(mappedUrl);
         }
         return url;
     };
 
     const int x = dropEvent->property("x").toInt();
     const int y = dropEvent->property("y").toInt();
     const QPoint dropPos = {x, y};
 
     if (m_dragInProgress && row == -1 && !m_urlChangedWhileDragging) {
         if (m_locked || mimeData->urls().isEmpty()) {
             return;
         }
 
         setSortMode(-1);
 
         for (const auto &url : mimeData->urls()) {
             m_dropTargetPositions.insert(url.fileName(), dropPos);
             m_screenMapper->addMapping(mappableUrl(url), m_screen, ScreenMapper::DelayedSignal);
             m_screenMapper->removeItemFromDisabledScreen(mappableUrl(url));
         }
         emit move(x, y, mimeData->urls());
 
         return;
     }
 
     if (mimeData->hasFormat(QStringLiteral("application/x-kde-ark-dndextract-service")) &&
         mimeData->hasFormat(QStringLiteral("application/x-kde-ark-dndextract-path"))) {
         const QString remoteDBusClient = mimeData->data(QStringLiteral("application/x-kde-ark-dndextract-service"));
         const QString remoteDBusPath = mimeData->data(QStringLiteral("application/x-kde-ark-dndextract-path"));
 
         QDBusMessage message =
             QDBusMessage::createMethodCall(remoteDBusClient, remoteDBusPath,
                                             QStringLiteral("org.kde.ark.DndExtract"),
                                             QStringLiteral("extractSelectedFilesTo"));
         message.setArguments({dropTargetUrl.toDisplayString(QUrl::PreferLocalFile)});
 
         QDBusConnection::sessionBus().call(message, QDBus::NoBlock);
 
         return;
     }
 
     if (idx.isValid() && !(flags(idx) & Qt::ItemIsDropEnabled)) {
         return;
     }
 
 
     if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
         if (isDropBetweenSharedViews(mimeData->urls(), dropTargetFolderUrl)) {
             setSortMode(-1);
             for (const auto &url : mimeData->urls()) {
                 m_dropTargetPositions.insert(url.fileName(), dropPos);
                 m_screenMapper->addMapping(mappableUrl(url), m_screen, ScreenMapper::DelayedSignal);
                 m_screenMapper->removeItemFromDisabledScreen(mappableUrl(url));
             }
             m_dropTargetPositionsCleanup->start();
             return;
         }
     }
 
     Qt::DropAction proposedAction((Qt::DropAction)dropEvent->property("proposedAction").toInt());
     Qt::DropActions possibleActions(dropEvent->property("possibleActions").toInt());
     Qt::MouseButtons buttons(dropEvent->property("buttons").toInt());
     Qt::KeyboardModifiers modifiers(dropEvent->property("modifiers").toInt());
 
     auto pos = target->mapToScene(dropPos).toPoint();
     pos = target->window()->mapToGlobal(pos);
     QDropEvent ev(pos, possibleActions, mimeData, buttons, modifiers);
     ev.setDropAction(proposedAction);
 
     KIO::DropJob *dropJob = KIO::drop(&ev, dropTargetUrl);
     dropJob->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
     // The QMimeData we extract from the DropArea's drop event is deleted as soon as this method
     // ends but we need to keep a copy for when popupMenuAboutToShow fires.
     QMimeData *mimeCopy = new QMimeData();
     for (const QString &format : mimeData->formats()) {
         mimeCopy->setData(format, mimeData->data(format));
     }
 
     connect(dropJob, &KIO::DropJob::popupMenuAboutToShow, this, [this, mimeCopy, x, y, dropJob](const KFileItemListProperties &) {
         emit popupMenuAboutToShow(dropJob, mimeCopy, x, y);
         mimeCopy->deleteLater();
     });
 
     /*
      * Position files that come from a drag'n'drop event at the drop event
      * target position. To do so, we first listen to copy job to figure out
      * the target URL. Then we store the position of this drop event in the
      * hash and eventually trigger a move request when we get notified about
      * the new file event from the source model.
      */
     connect(dropJob, &KIO::DropJob::copyJobStarted, this, [this, dropPos, dropTargetUrl](KIO::CopyJob* copyJob) {
         auto map = [this, dropPos, dropTargetUrl](const QUrl &targetUrl) {
             m_dropTargetPositions.insert(targetUrl.fileName(), dropPos);
             m_dropTargetPositionsCleanup->start();
 
             if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
                 // assign a screen for the item before the copy is actually done, so
                 // filterAcceptsRow doesn't assign the default screen to it
                 QUrl url = resolvedUrl();
                 // if the folderview's folder is a standard path, just use the targetUrl for mapping
                 if (targetUrl.toString().startsWith(url.toString())) {
                     m_screenMapper->addMapping(targetUrl, m_screen, ScreenMapper::DelayedSignal);
                 } else if (targetUrl.toString().startsWith(dropTargetUrl.toString())) {
                     // if the folderview's folder is a special path, like desktop:// , we need to convert
                     // the targetUrl file:// path to a desktop:/ path for mapping
                     auto destPath = dropTargetUrl.path();
                     auto filePath = targetUrl.path();
                     if (filePath.startsWith(destPath)) {
                         url.setPath(filePath.remove(0, destPath.length()));
                         m_screenMapper->addMapping(url, m_screen, ScreenMapper::DelayedSignal);
                     }
                 }
             }
         };
         // remember drop target position for target URL and forget about the source URL
         connect(copyJob, &KIO::CopyJob::copyingDone,
                 this, [this, map](KIO::Job *, const QUrl &, const QUrl &targetUrl, const QDateTime &, bool, bool) {
             map(targetUrl);
         });
         connect(copyJob, &KIO::CopyJob::copyingLinkDone,
                 this, [this, map](KIO::Job *, const QUrl &, const QString &, const QUrl &targetUrl) {
             map(targetUrl);
         });
     });
 }
 
 void FolderModel::dropCwd(QObject* dropEvent)
 {
     QMimeData *mimeData = qobject_cast<QMimeData *>(dropEvent->property("mimeData").value<QObject *>());
 
     if (!mimeData) {
         return;
     }
 
     if (mimeData->hasFormat(QStringLiteral("application/x-kde-ark-dndextract-service")) &&
         mimeData->hasFormat(QStringLiteral("application/x-kde-ark-dndextract-path"))) {
         const QString remoteDBusClient = mimeData->data(QStringLiteral("application/x-kde-ark-dndextract-service"));
         const QString remoteDBusPath = mimeData->data(QStringLiteral("application/x-kde-ark-dndextract-path"));
 
         QDBusMessage message =
             QDBusMessage::createMethodCall(remoteDBusClient, remoteDBusPath,
                                             QStringLiteral("org.kde.ark.DndExtract"),
                                             QStringLiteral("extractSelectedFilesTo"));
         message.setArguments(QVariantList() << m_dirModel->dirLister()->url().adjusted(QUrl::PreferLocalFile).toString());
 
         QDBusConnection::sessionBus().call(message, QDBus::NoBlock);
     } else {
         Qt::DropAction proposedAction((Qt::DropAction)dropEvent->property("proposedAction").toInt());
         Qt::DropActions possibleActions(dropEvent->property("possibleActions").toInt());
         Qt::MouseButtons buttons(dropEvent->property("buttons").toInt());
         Qt::KeyboardModifiers modifiers(dropEvent->property("modifiers").toInt());
 
         QDropEvent ev(QPoint(), possibleActions, mimeData, buttons, modifiers);
         ev.setDropAction(proposedAction);
 
         KIO::DropJob *dropJob = KIO::drop(&ev, m_dirModel->dirLister()->url().adjusted(QUrl::PreferLocalFile));
         dropJob->uiDelegate()->setAutoErrorHandlingEnabled(true);
     }
 }
 
 void FolderModel::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
 {
     QModelIndexList indices = selected.indexes();
     indices.append(deselected.indexes());
 
     QVector<int> roles;
     roles.append(SelectedRole);
 
     foreach(const QModelIndex &index, indices) {
         emit dataChanged(index, index, roles);
     }
 
     if (!m_selectionModel->hasSelection()) {
         clearDragImages();
     } else {
         foreach (const QModelIndex &idx, deselected.indexes()) {
             if (m_dragImages.contains(idx.row())) {
                 DragImage *image = m_dragImages.value(idx.row());
                 delete image;
                 m_dragImages.remove(idx.row());
             }
         }
     }
 }
 
 bool FolderModel::isBlank(int row) const
 {
     if (row < 0) {
         return true;
     }
 
     return data(index(row, 0), BlankRole).toBool();
 }
 
 QVariant FolderModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     if (role == BlankRole) {
         return m_dragIndexes.contains(index);
     } else if (role == OverlaysRole) {
         const KFileItem item = itemForIndex(index);
         return item.overlays();
     } else if (role == SelectedRole) {
         return m_selectionModel->isSelected(index);
     } else if (role == IsDirRole) {
         const QUrl &url = data(index, UrlRole).toUrl();
 
         if (m_isDirCache.contains(url)) {
             return m_isDirCache[url];
         } else {
             return isDir(mapToSource(index), m_dirModel);
         }
     } else if (role == IsLinkRole) {
         const KFileItem item = itemForIndex(index);
         return item.isLink();
     } else if (role == IsHiddenRole) {
         const KFileItem item = itemForIndex(index);
         return item.isHidden();
     } else if (role == UrlRole) {
         return itemForIndex(index).url();
     } else if (role == LinkDestinationUrl) {
         const KFileItem item = itemForIndex(index);
 
         if (m_parseDesktopFiles && item.isDesktopFile()) {
             const KDesktopFile file(item.targetUrl().path());
 
             if (file.hasLinkType()) {
                 return file.readUrl();
             }
         }
 
         return item.url();
     } else if (role == SizeRole) {
         bool isDir = data(index, IsDirRole).toBool();
 
         if (!isDir) {
             return m_dirModel->data(mapToSource(QSortFilterProxyModel::index(index.row(), 1)), Qt::DisplayRole);
         }
     } else if (role == TypeRole) {
         return m_dirModel->data(mapToSource(QSortFilterProxyModel::index(index.row(), 6)), Qt::DisplayRole);
     } else if (role == FileNameRole) {
         return itemForIndex(index).url().fileName();
     }
 
     return QSortFilterProxyModel::data(index, role);
 }
 
 int FolderModel::indexForUrl(const QUrl& url) const
 {
     return mapFromSource(m_dirModel->indexForUrl(url)).row();
 }
 
 KFileItem FolderModel::itemForIndex(const QModelIndex &index) const
 {
     return m_dirModel->itemForIndex(mapToSource(index));
 }
 
 bool FolderModel::isDir(const QModelIndex &index, const KDirModel *dirModel) const
 {
     KFileItem item = dirModel->itemForIndex(index);
     if (item.isDir()) {
         return true;
     }
 
     if (m_parseDesktopFiles && item.isDesktopFile()) {
         // Check if the desktop file is a link to a directory
         KDesktopFile file(item.targetUrl().path());
 
         if (file.hasLinkType()) {
             const QUrl url(file.readUrl());
 
             if (!m_isDirCache.contains(item.url()) && KProtocolInfo::protocolClass(url.scheme()) == QStringLiteral(":local")) {
                 KIO::StatJob *job = KIO::stat(url, KIO::HideProgressInfo);
                 job->setProperty("org.kde.plasma.folder_url", item.url());
                 job->setSide(KIO::StatJob::SourceSide);
                 job->setDetails(0);
                 connect(job, &KJob::result, this, &FolderModel::statResult);
             }
         }
     }
 
     return false;
 }
 
 void FolderModel::statResult(KJob *job)
 {
     KIO::StatJob *statJob = static_cast<KIO::StatJob*>(job);
 
     const QUrl &url = statJob->property("org.kde.plasma.folder_url").toUrl();
     const QModelIndex &idx = index(indexForUrl(url), 0);
 
     if (idx.isValid()) {
         m_isDirCache[url] = statJob->statResult().isDir();
 
         emit dataChanged(idx, idx, QVector<int>() << IsDirRole);
     }
 }
 
 void FolderModel::evictFromIsDirCache(const KFileItemList& items)
 {
     foreach (const KFileItem &item, items) {
         m_screenMapper->removeFromMap(item.url());
         m_isDirCache.remove(item.url());
     }
 }
 
 bool FolderModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
     const KDirModel *dirModel = static_cast<KDirModel*>(sourceModel());
 
     if (m_sortDirsFirst || left.column() == KDirModel::Size) {
         bool leftIsDir = isDir(left, dirModel);
         bool rightIsDir = isDir(right, dirModel);
 
         if (leftIsDir && !rightIsDir) {
             return (sortOrder() == Qt::AscendingOrder);
         }
 
         if (!leftIsDir && rightIsDir) {
             return (sortOrder() == Qt::DescendingOrder);
         }
     }
 
     const KFileItem leftItem = dirModel->data(left, KDirModel::FileItemRole).value<KFileItem>();
     const KFileItem rightItem = dirModel->data(right, KDirModel::FileItemRole).value<KFileItem>();
     const int column = left.column();
     int result = 0;
 
     switch (column) {
         case KDirModel::Size: {
                 if (isDir(left, dirModel) && isDir(right, dirModel)) {
                     const int leftChildCount = dirModel->data(left, KDirModel::ChildCountRole).toInt();
                     const int rightChildCount = dirModel->data(right, KDirModel::ChildCountRole).toInt();
                     if (leftChildCount < rightChildCount)
                         result = -1;
                     else if (leftChildCount > rightChildCount)
                         result = +1;
                 } else {
                     const KIO::filesize_t leftSize = leftItem.size();
                     const KIO::filesize_t rightSize = rightItem.size();
                     if (leftSize < rightSize)
                         result = -1;
                     else if (leftSize > rightSize)
                         result = +1;
                 }
 
                 break;
             }
         case KDirModel::ModifiedTime: {
                 const QDateTime leftTime = leftItem.time(KFileItem::ModificationTime);
                 const QDateTime rightTime = rightItem.time(KFileItem::ModificationTime);
                 if (leftTime < rightTime)
                     result = -1;
                 else if (leftTime > rightTime)
                     result = +1;
 
                 break;
             }
         case KDirModel::Type:
             result = QString::compare(dirModel->data(left, Qt::DisplayRole).toString(),
                                       dirModel->data(right, Qt::DisplayRole).toString());
             break;
 
         default:
             break;
     }
 
     if (result != 0)
         return result < 0;
 
     QCollator collator;
 
     result = collator.compare(leftItem.text(), rightItem.text());
 
     if (result != 0)
         return result < 0;
 
     result = collator.compare(leftItem.name(), rightItem.name());
 
     if (result != 0)
         return result < 0;
 
     return QString::compare(leftItem.url().url(), rightItem.url().url(), Qt::CaseSensitive);
 }
 
 Qt::DropActions FolderModel::supportedDragActions() const
 {
     return Qt::CopyAction | Qt::MoveAction | Qt::LinkAction;
 }
 
 inline bool FolderModel::matchMimeType(const KFileItem &item) const
 {
     if (m_mimeSet.isEmpty()) {
         return false;
     }
 
     if (m_mimeSet.contains(QStringLiteral("all/all")) || m_mimeSet.contains(QStringLiteral("all/allfiles"))) {
         return true;
     }
 
     const QString mimeType = item.determineMimeType().name();
     return m_mimeSet.contains(mimeType);
 }
 
 inline bool FolderModel::matchPattern(const KFileItem &item) const
 {
     if (m_filterPatternMatchAll) {
         return true;
     }
 
     const QString name = item.name();
     QListIterator<QRegExp> i(m_regExps);
     while (i.hasNext()) {
         if (i.next().exactMatch(name)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool FolderModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     const KDirModel *dirModel = static_cast<KDirModel*>(sourceModel());
     const KFileItem item = dirModel->itemForIndex(dirModel->index(sourceRow, KDirModel::Name, sourceParent));
 
     if (m_usedByContainment && !m_screenMapper->sharedDesktops()) {
         const QUrl url = item.url();
         const int screen = m_screenMapper->screenForItem(url);
         // don't do anything if the folderview is not associated with a screen
         if (m_screen != -1) {
             if (screen == -1) {
                 // The item is not associated with a screen, probably because this is the first
                 // time we see it or the folderview was previously used as a regular applet.
                 // Associated with this folderview if the view is on the first available screen
                 if (m_screen == m_screenMapper->firstAvailableScreen(resolvedUrl())) {
                     m_screenMapper->addMapping(url, m_screen, ScreenMapper::DelayedSignal);
                 } else {
                     return false;
                 }
             } else if (m_screen != screen) {
                 // the item belongs to a different screen, filter it out
                 return false;
             }
         }
     }
 
     if (m_filterMode == NoFilter) {
         return true;
     }
 
     if (m_filterMode == FilterShowMatches) {
         return (matchPattern(item) && matchMimeType(item));
     } else {
         return !(matchPattern(item) && matchMimeType(item));
     }
 }
 
 void FolderModel::createActions()
 {
     KIO::FileUndoManager *manager = KIO::FileUndoManager::self();
 
     QAction *cut = KStandardAction::cut(this, &FolderModel::cut, this);
     QAction *copy = KStandardAction::copy(this, &FolderModel::copy, this);
 
     QAction *undo = KStandardAction::undo(manager, &KIO::FileUndoManager::undo, this);
     undo->setEnabled(manager->undoAvailable());
     undo->setShortcutContext(Qt::WidgetShortcut);
     connect(manager, SIGNAL(undoAvailable(bool)), undo, SLOT(setEnabled(bool)));
     connect(manager, &KIO::FileUndoManager::undoTextChanged, this, &FolderModel::undoTextChanged);
 
     QAction *paste = KStandardAction::paste(this, &FolderModel::paste, this);
     QAction *pasteTo = KStandardAction::paste(this, &FolderModel::pasteTo, this);
 
     QAction *reload = new QAction(i18n("&Reload"), this);
     connect(reload, &QAction::triggered, this, &FolderModel::refresh);
 
     QAction *refresh = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")), i18n("&Refresh View"), this);
     connect(refresh, &QAction::triggered, this, &FolderModel::refresh);
 
     QAction *rename = new QAction(QIcon::fromTheme(QStringLiteral("edit-rename")), i18n("&Rename"), this);
     connect(rename, &QAction::triggered, this, &FolderModel::requestRename);
 
     QAction *trash = new QAction(QIcon::fromTheme(QStringLiteral("user-trash")), i18n("&Move to Trash"), this);
     connect(trash, &QAction::triggered, this, &FolderModel::moveSelectedToTrash);
 
     QAction *emptyTrash = new QAction(QIcon::fromTheme(QStringLiteral("trash-empty")), i18n("&Empty Trash Bin"), this);
     connect(emptyTrash, &QAction::triggered, this, &FolderModel::emptyTrashBin);
 
     QAction *restoreFromTrash = new QAction(i18nc("Restore from trash", "Restore"), this);
     connect(restoreFromTrash, &QAction::triggered, this, &FolderModel::restoreSelectedFromTrash);
 
     QAction *del = new QAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18n("&Delete"), this);
     connect(del, &QAction::triggered, this, &FolderModel::deleteSelected);
 
     QAction *actOpen = new QAction(QIcon::fromTheme(QStringLiteral("window-new")), i18n("&Open"), this);
     connect(actOpen, &QAction::triggered, this, &FolderModel::openSelected);
 
     m_actionCollection.addAction(QStringLiteral("open"), actOpen);
     m_actionCollection.addAction(QStringLiteral("cut"), cut);
     m_actionCollection.addAction(QStringLiteral("undo"), undo);
     m_actionCollection.addAction(QStringLiteral("copy"), copy);
     m_actionCollection.addAction(QStringLiteral("paste"), paste);
     m_actionCollection.addAction(QStringLiteral("pasteto"), pasteTo);
     m_actionCollection.addAction(QStringLiteral("reload"), reload);
     m_actionCollection.addAction(QStringLiteral("refresh"), refresh);
     m_actionCollection.addAction(QStringLiteral("rename"), rename);
     m_actionCollection.addAction(QStringLiteral("trash"), trash);
     m_actionCollection.addAction(QStringLiteral("del"), del);
     m_actionCollection.addAction(QStringLiteral("restoreFromTrash"), restoreFromTrash);
     m_actionCollection.addAction(QStringLiteral("emptyTrash"), emptyTrash);
 
     m_newMenu = new KNewFileMenu(&m_actionCollection, QStringLiteral("newMenu"), QApplication::desktop());
     m_newMenu->setModal(false);
     connect(m_newMenu, &KNewFileMenu::directoryCreated, this, &FolderModel::newFileMenuItemCreated);
     connect(m_newMenu, &KNewFileMenu::fileCreated, this, &FolderModel::newFileMenuItemCreated);
 
     m_copyToMenu = new KFileCopyToMenu(nullptr);
 }
 
 QAction* FolderModel::action(const QString &name) const
 {
     return m_actionCollection.action(name);
 }
 
 QObject* FolderModel::newMenu() const
 {
     return m_newMenu->menu();
 }
 
 void FolderModel::updateActions()
 {
     if (m_newMenu) {
         m_newMenu->checkUpToDate();
         m_newMenu->setPopupFiles(m_dirModel->dirLister()->url());
         // we need to set here as well, when the menu is shown via AppletInterface::eventFilter
         m_menuPosition = QCursor::pos();
     }
 
     const bool isTrash = (resolvedUrl().scheme() == QLatin1String("trash"));
 
     QAction *emptyTrash = m_actionCollection.action(QStringLiteral("emptyTrash"));
 
     if (emptyTrash) {
         if (isTrash) {
             emptyTrash->setVisible(true);
             KConfig trashConfig(QStringLiteral("trashrc"), KConfig::SimpleConfig);
             emptyTrash->setEnabled(!trashConfig.group("Status").readEntry("Empty", true));
         } else {
             emptyTrash->setVisible(false);
         }
     }
 
     if (QAction *restoreFromTrash = m_actionCollection.action(QStringLiteral("restoreFromTrash"))) {
         restoreFromTrash->setVisible(isTrash);
     }
 
     QAction *paste = m_actionCollection.action(QStringLiteral("paste"));
 
     if (paste) {
         bool enable = false;
 
         const QString pasteText = KIO::pasteActionText(QApplication::clipboard()->mimeData(),
             &enable, rootItem());
 
         if (enable) {
             paste->setText(pasteText);
             paste->setEnabled(true);
         } else {
             paste->setText(i18n("&Paste"));
             paste->setEnabled(false);
         }
 
         QAction* pasteTo = m_actionCollection.action(QStringLiteral("pasteto"));
 
         if (pasteTo) {
             pasteTo->setEnabled(paste->isEnabled());
             pasteTo->setText(paste->text());
         }
     }
 }
 
 void FolderModel::openContextMenu(QQuickItem *visualParent)
 {
     QModelIndexList indexes = m_selectionModel->selectedIndexes();
 
     if (m_usedByContainment && !KAuthorized::authorize(QStringLiteral("action/kdesktop_rmb"))) {
         return;
     }
 
     updateActions();
 
     QMenu *menu = new QMenu();
     if (!m_fileItemActions) {
         m_fileItemActions = new KFileItemActions(this);
         m_fileItemActions->setParentWidget(QApplication::desktop());
     }
 
     if (indexes.isEmpty()) {
         menu->addAction(m_actionCollection.action(QStringLiteral("newMenu")));
         menu->addSeparator();
         menu->addAction(m_actionCollection.action(QStringLiteral("paste")));
         menu->addAction(m_actionCollection.action(QStringLiteral("undo")));
         menu->addAction(m_actionCollection.action(QStringLiteral("refresh")));
         menu->addAction(m_actionCollection.action(QStringLiteral("emptyTrash")));
         menu->addSeparator();
 
         KFileItemListProperties itemProperties(KFileItemList() << rootItem());
         m_fileItemActions->setItemListProperties(itemProperties);
 
         menu->addAction(m_fileItemActions->preferredOpenWithAction(QString()));
     } else {
         KFileItemList items;
         QList<QUrl> urls;
         bool hasRemoteFiles = false;
         bool isTrashLink = false;
 
         items.reserve(indexes.count());
         urls.reserve(indexes.count());
         foreach (const QModelIndex &index, indexes) {
             KFileItem item = itemForIndex(index);
             if (!item.isNull()) {
                 hasRemoteFiles |= item.localPath().isEmpty();
                 items.append(item);
                 urls.append(item.url());
             }
         }
         KFileItemListProperties itemProperties(items);
 
         // Check if we're showing the menu for the trash link
         if (items.count() == 1 && items.at(0).isDesktopFile()) {
             KDesktopFile file(items.at(0).localPath());
             if (file.hasLinkType() && file.readUrl() == QLatin1String("trash:/")) {
                 isTrashLink = true;
             }
         }
 
         // Start adding the actions:
         menu->addAction(m_actionCollection.action(QStringLiteral("open")));
         menu->addSeparator();
         if (itemProperties.supportsDeleting()) {
             menu->addAction(m_actionCollection.action(QStringLiteral("cut")));
         }
         menu->addAction(m_actionCollection.action(QStringLiteral("copy")));
 
         if (itemProperties.isDirectory() && itemProperties.supportsWriting()) {
             menu->addAction(m_actionCollection.action(QStringLiteral("pasteto")));
         }
 
         menu->addAction(m_actionCollection.action(QStringLiteral("rename")));
         menu->addAction(m_actionCollection.action(QStringLiteral("restoreFromTrash")));
 
         KSharedConfig::Ptr globalConfig = KSharedConfig::openConfig(QStringLiteral("kdeglobals"), KConfig::NoGlobals);
         KConfigGroup cg(globalConfig, "KDE");
         bool showDeleteCommand = cg.readEntry("ShowDeleteCommand", false);
 
         // When we're showing the menu for the trash link, offer "Empty Trash" instead
         // of the "Move to Trash" action.
         if (isTrashLink) {
             QAction *emptyTrashAction = m_actionCollection.action(QStringLiteral("emptyTrash"));
             if (emptyTrashAction) {
                 // We explicitly force the action visible here, as it relies on the KFileItemList
                 // we collected above. In updateActions() we don't have it and since this is always
                 // called before we open the menu, it would correct visibility again when opening
                 // the context menu for other items later.
                 emptyTrashAction->setVisible(true);
                 menu->addAction(emptyTrashAction);
             }
         } else {
             if (!hasRemoteFiles && itemProperties.supportsMoving()) {
                 menu->addAction(m_actionCollection.action(QStringLiteral("trash")));
             } else {
                 showDeleteCommand = true;
             }
         }
         if (showDeleteCommand && itemProperties.supportsDeleting()) {
             menu->addAction(m_actionCollection.action(QStringLiteral("del")));
         }
 
         // "Open with" actions
         m_fileItemActions->setItemListProperties(itemProperties);
         m_fileItemActions->addOpenWithActionsTo(menu);
         // Service actions
         m_fileItemActions->addServiceActionsTo(menu);
         menu->addSeparator();
         // Plugin actions
         m_fileItemActions->addPluginActionsTo(menu);
 
         // Copy To, Move To
         KSharedConfig::Ptr dolphin = KSharedConfig::openConfig(QStringLiteral("dolphinrc"));
         if (KConfigGroup(dolphin, "General").readEntry("ShowCopyMoveMenu", false)) {
             m_copyToMenu->setUrls(urls);
             m_copyToMenu->setReadOnly(!itemProperties.supportsMoving());
             m_copyToMenu->addActionsTo(menu);
             menu->addSeparator();
         }
 
         // Properties
         if (KPropertiesDialog::canDisplay(items)) {
             QAction *act = new QAction(menu);
             act->setText(i18n("&Properties"));
             QObject::connect(act, &QAction::triggered, this, &FolderModel::openPropertiesDialog);
             menu->addAction(act);
         }
 
     }
 
     if (visualParent) {
         m_menuPosition = visualParent->mapToGlobal(QPointF(0, visualParent->height())).toPoint();
     } else {
         m_menuPosition = QCursor::pos();
     }
     menu->popup(m_menuPosition);
     connect(menu, &QMenu::aboutToHide, [menu]() { menu->deleteLater(); });
 }
 
 void FolderModel::openPropertiesDialog()
 {
     const QModelIndexList indexes = m_selectionModel->selectedIndexes();
     if (indexes.isEmpty()) {
         return;
     }
 
     KFileItemList items;
     items.reserve(indexes.count());
     for (const QModelIndex &index : indexes) {
         KFileItem item = itemForIndex(index);
         if (!item.isNull()) {
             items.append(item);
         }
     }
 
     if (!KPropertiesDialog::canDisplay(items)) {
         return;
     }
 
     KPropertiesDialog::showDialog(items, nullptr, false /*non modal*/);
 }
 
 void FolderModel::linkHere(const QUrl &sourceUrl)
 {
     KIO::CopyJob *job = KIO::link(sourceUrl, m_dirModel->dirLister()->url());
     KIO::FileUndoManager::self()->recordCopyJob(job);
 }
 
 QList<QUrl> FolderModel::selectedUrls() const
 {
     const auto indexes = m_selectionModel->selectedIndexes();
 
     QList<QUrl> urls;
     urls.reserve(indexes.count());
 
     for (const QModelIndex &index : indexes) {
         urls.append(itemForIndex(index).url());
     }
 
     return urls;
 }
 
 void FolderModel::copy()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     QMimeData *mimeData = QSortFilterProxyModel::mimeData(m_selectionModel->selectedIndexes());
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void FolderModel::cut()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     QMimeData *mimeData = QSortFilterProxyModel::mimeData(m_selectionModel->selectedIndexes());
     KIO::setClipboardDataCut(mimeData, true);
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void FolderModel::paste()
 {
     KIO::paste(QApplication::clipboard()->mimeData(), m_dirModel->dirLister()->url());
 }
 
 void FolderModel::pasteTo()
 {
     const QList<QUrl> urls = selectedUrls();
     Q_ASSERT(urls.count() == 1);
     KIO::paste(QApplication::clipboard()->mimeData(), urls.first());
 }
 
 void FolderModel::refresh()
 {
     m_errorString.clear();
     emit errorStringChanged();
 
     m_dirModel->dirLister()->updateDirectory(m_dirModel->dirLister()->url());
 }
 
 QObject *FolderModel::appletInterface() const
 {
     return m_appletInterface;
 }
 
 void FolderModel::setAppletInterface(QObject *appletInterface)
 {
     if (m_appletInterface != appletInterface) {
         Q_ASSERT(!m_appletInterface);
 
         m_appletInterface = appletInterface;
 
         if (appletInterface) {
             Plasma::Applet *applet = appletInterface->property("_plasma_applet").value<Plasma::Applet *>();
 
             if (applet) {
                 Plasma::Containment *containment = applet->containment();
 
                 if (containment) {
                     Plasma::Corona *corona = containment->corona();
 
                     if (corona) {
                         m_screenMapper->setCorona(corona);
                     }
                     setScreen(containment->screen());
                     connect(containment, &Plasma::Containment::screenChanged, this, &FolderModel::setScreen);
                 }
             }
         }
 
         emit appletInterfaceChanged();
     }
 }
 
 void FolderModel::moveSelectedToTrash()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     const QList<QUrl> urls = selectedUrls();
     KIO::JobUiDelegate uiDelegate;
 
     if (uiDelegate.askDeleteConfirmation(urls, KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job* job = KIO::trash(urls);
         job->uiDelegate()->setAutoErrorHandlingEnabled(true);
         KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Trash, urls, QUrl(QStringLiteral("trash:/")), job);
     }
 }
 
 void FolderModel::deleteSelected()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     const QList<QUrl> urls = selectedUrls();
     KIO::JobUiDelegate uiDelegate;
 
     if (uiDelegate.askDeleteConfirmation(urls, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job* job = KIO::del(urls);
         job->uiDelegate()->setAutoErrorHandlingEnabled(true);
     }
 }
 
 void FolderModel::openSelected()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     const QList<QUrl> urls = selectedUrls();
     for (const QUrl &url : urls) {
         (void) new KRun(url, nullptr);
     }
 }
 
 void FolderModel::undo()
 {
     if (QAction *action = m_actionCollection.action(QStringLiteral("undo"))) {
         // trigger() doesn't check enabled and would crash if invoked nonetheless.
         if (action->isEnabled()) {
             action->trigger();
         }
     }
 }
 
 void FolderModel::emptyTrashBin()
 {
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(QApplication::desktop());
 
     if (uiDelegate.askDeleteConfirmation(QList<QUrl>(), KIO::JobUiDelegate::EmptyTrash, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job* job = KIO::emptyTrash();
         job->uiDelegate()->setAutoErrorHandlingEnabled(true);
     }
 }
 
 void FolderModel::restoreSelectedFromTrash()
 {
     if (!m_selectionModel->hasSelection()) {
         return;
     }
 
     const auto &urls = selectedUrls();
 
     KIO::RestoreJob *job = KIO::restoreFromTrash(urls);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 }
 
 void FolderModel::undoTextChanged(const QString &text)
 {
     if (QAction *action = m_actionCollection.action(QStringLiteral("undo"))) {
         action->setText(text);
     }
 }
 
diff --git a/kaccess/main.cpp b/kaccess/main.cpp
index 311764ebe..71794b104 100644
--- a/kaccess/main.cpp
+++ b/kaccess/main.cpp
@@ -1,93 +1,94 @@
 /*
     Copyright 2000 Matthias Hölzer-Klüpfel <hoelzer@kde.org>
     Copyright 2014 Frederik Gladhorn <gladhorn@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 "kaccess.h"
 #include <QDebug>
 #include <QApplication>
 #include <QSessionManager>
 #include <QX11Info>
 #include <KAboutData>
 #include <KLocalizedString>
-#include <KDBusService>
 #include <Kdelibs4ConfigMigrator>
 
 extern "C" Q_DECL_EXPORT int kdemain(int argc, char * argv[])
 {
-    // we need an application object for QX11Info
-    QApplication app(argc, argv);
-    KAccessApp acc;
-
     Kdelibs4ConfigMigrator migrate(QStringLiteral("kaccess"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("kaccessrc"));
     migrate.migrate();
 
     QGuiApplication::setFallbackSessionManagementEnabled(false);
 
-    KAboutData about("kaccess", QString(), i18n("KDE Accessibility Tool"),
-                      {}, KAboutLicense::GPL_V2,
-                      i18n("(c) 2000, Matthias Hoelzer-Kluepfel"));
-
-    about.addAuthor(i18n("Matthias Hoelzer-Kluepfel"), i18n("Author") , QStringLiteral("hoelzer@kde.org"));
-
     //this application is currently only relevant on X, force to run under X
     //note if someone does port this we still need to run kaccess under X for xwayland apps
     qputenv("QT_QPA_PLATFORM", "xcb");
 
     // verify the Xlib has matching XKB extension
     int major = XkbMajorVersion;
     int minor = XkbMinorVersion;
     if (!XkbLibraryVersion(&major, &minor)) {
         qWarning() << "Xlib XKB extension does not match";
         return 1;
     }
     qDebug() << "Xlib XKB extension major=" << major << " minor=" << minor;
 
+    // we need an application object for QX11Info
+    QApplication app(argc, argv);
+
+    KAboutData about("kaccess", QString(), i18n("KDE Accessibility Tool"),
+                      {}, KAboutLicense::GPL_V2,
+                      i18n("(c) 2000, Matthias Hoelzer-Kluepfel"));
+
+    about.addAuthor(i18n("Matthias Hoelzer-Kluepfel"), i18n("Author") , QStringLiteral("hoelzer@kde.org"));
+    // set data as used for D-Bus by KAccessApp
+    KAboutData::setApplicationData(about);
+
+    KAccessApp acc;
     if (acc.isFailed()) {
         return 1;
     }
 
     auto disableSessionManagement = [](QSessionManager &sm) {
         sm.setRestartHint(QSessionManager::RestartNever);
     };
 
     QObject::connect(&app, &QGuiApplication::commitDataRequest, disableSessionManagement);
     QObject::connect(&app, &QGuiApplication::saveStateRequest, disableSessionManagement);
 
     // verify the X server has matching XKB extension
     // if yes, the XKB extension is initialized
     int opcode_rtrn;
     int error_rtrn;
     int xkb_opcode;
     if (!XkbQueryExtension(QX11Info::display(), &opcode_rtrn, &xkb_opcode, &error_rtrn,
                            &major, &minor)) {
         qWarning() << "X server has not matching XKB extension" << endl;
         return 1;
     }
     qDebug() << "X server XKB extension major=" << major << " minor=" << minor;
 
     app.installNativeEventFilter(&acc);
 
     //Without that, the application dies when the dialog is closed only once.
     app.setQuitOnLastWindowClosed(false);
 
     acc.setXkbOpcode(xkb_opcode);
     return app.exec();
 }