diff --git a/autotests/integration/window_selection_test.cpp b/autotests/integration/window_selection_test.cpp
index f25d900f6..18472f6df 100644
--- a/autotests/integration/window_selection_test.cpp
+++ b/autotests/integration/window_selection_test.cpp
@@ -1,369 +1,455 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "cursor.h"
 #include "keyboard_input.h"
 #include "platform.h"
 #include "pointer_input.h"
 #include "shell_client.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/shell.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_window_selection-0");
 
 class TestWindowSelection : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testSelectOnWindowPointer();
     void testSelectOnWindowKeyboard_data();
     void testSelectOnWindowKeyboard();
     void testCancelOnWindowPointer();
     void testCancelOnWindowKeyboard();
+
+    void testSelectPointPointer();
 };
 
 void TestWindowSelection::initTestCase()
 {
     qRegisterMetaType<KWin::ShellClient*>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestWindowSelection::init()
 {
     QVERIFY(Test::setupWaylandConnection(s_socketName, Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestWindowSelection::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestWindowSelection::testSelectOnWindowPointer()
 {
     // this test verifies window selection through pointer works
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->geometry().center());
     QCOMPARE(input()->pointer()->window().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QVERIFY(input()->pointer()->window().isNull());
 
     // updating the pointer should not change anything
     input()->pointer()->update();
     QVERIFY(input()->pointer()->window().isNull());
     // updating keyboard should also not change
     input()->keyboard()->update();
 
     // perform a right button click
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     // now release
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->pointer()->window().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
 }
 
 void TestWindowSelection::testSelectOnWindowKeyboard_data()
 {
     QTest::addColumn<qint32>("key");
 
     QTest::newRow("enter") << KEY_ENTER;
     QTest::newRow("keypad enter") << KEY_KPENTER;
     QTest::newRow("space") << KEY_SPACE;
 }
 
 void TestWindowSelection::testSelectOnWindowKeyboard()
 {
     // this test verifies window selection through keyboard key
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     QVERIFY(!client->geometry().contains(KWin::Cursor::pos()));
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(keyboardLeftSpy.wait());
     QCOMPARE(pointerLeftSpy.count(), 0);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate key press
     quint32 timestamp = 0;
     // move cursor through keys
     auto keyPress = [&timestamp] (qint32 key) {
         kwinApp()->platform()->keyboardKeyPressed(key, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(key, timestamp++);
     };
     while (KWin::Cursor::pos().x() >= client->geometry().x() + client->geometry().width()) {
         keyPress(KEY_LEFT);
     }
     while (KWin::Cursor::pos().x() <= client->geometry().x()) {
         keyPress(KEY_RIGHT);
     }
     while (KWin::Cursor::pos().y() <= client->geometry().y()) {
         keyPress(KEY_DOWN);
     }
     while (KWin::Cursor::pos().y() >= client->geometry().y() + client->geometry().height()) {
         keyPress(KEY_UP);
     }
     QFETCH(qint32, key);
     kwinApp()->platform()->keyboardKeyPressed(key, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->pointer()->window().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 0);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 1);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyReleased(key, timestamp++);
 }
 
 void TestWindowSelection::testCancelOnWindowPointer()
 {
     // this test verifies that window selection cancels through right button click
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->geometry().center());
     QCOMPARE(input()->pointer()->window().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QVERIFY(!selectedWindow);
     QCOMPARE(input()->pointer()->window().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
 }
 
 void TestWindowSelection::testCancelOnWindowKeyboard()
 {
     // this test verifies that cancel window selection through escape key works
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->geometry().center());
     QCOMPARE(input()->pointer()->window().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QVERIFY(!selectedWindow);
     QCOMPARE(input()->pointer()->window().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, timestamp++);
 }
 
+void TestWindowSelection::testSelectPointPointer()
+{
+    // this test verifies point selection through pointer works
+    QScopedPointer<Surface> surface(Test::createSurface());
+    QScopedPointer<ShellSurface> shellSurface(Test::createShellSurface(surface.data()));
+    QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
+    QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
+    QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
+    QVERIFY(pointerEnteredSpy.isValid());
+    QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
+    QVERIFY(pointerLeftSpy.isValid());
+    QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
+    QVERIFY(keyboardEnteredSpy.isValid());
+    QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
+    QVERIFY(keyboardLeftSpy.isValid());
+
+    auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    QVERIFY(client);
+    QVERIFY(keyboardEnteredSpy.wait());
+    KWin::Cursor::setPos(client->geometry().center());
+    QCOMPARE(input()->pointer()->window().data(), client);
+    QVERIFY(pointerEnteredSpy.wait());
+
+    QPoint point;
+    auto callback = [&point] (const QPoint &p) {
+        point = p;
+    };
+
+    // start the interaction
+    QCOMPARE(input()->isSelectingWindow(), false);
+    kwinApp()->platform()->startInteractivePositionSelection(callback);
+    QCOMPARE(input()->isSelectingWindow(), true);
+    QCOMPARE(point, QPoint());
+    QCOMPARE(keyboardLeftSpy.count(), 0);
+    QVERIFY(pointerLeftSpy.wait());
+    if (keyboardLeftSpy.isEmpty()) {
+        QVERIFY(keyboardLeftSpy.wait());
+    }
+    QCOMPARE(pointerLeftSpy.count(), 1);
+    QCOMPARE(keyboardLeftSpy.count(), 1);
+
+    // trying again should not be allowed
+    QPoint point2;
+    kwinApp()->platform()->startInteractivePositionSelection([&point2] (const QPoint &p) {
+        point2 = p;
+    });
+    QCOMPARE(point2, QPoint(-1, -1));
+
+    // simulate left button press
+    quint32 timestamp = 0;
+    kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
+    // should not have ended the mode
+    QCOMPARE(input()->isSelectingWindow(), true);
+    QCOMPARE(point, QPoint());
+    QVERIFY(input()->pointer()->window().isNull());
+
+    // updating the pointer should not change anything
+    input()->pointer()->update();
+    QVERIFY(input()->pointer()->window().isNull());
+    // updating keyboard should also not change
+    input()->keyboard()->update();
+
+    // perform a right button click
+    kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
+    kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
+    // should not have ended the mode
+    QCOMPARE(input()->isSelectingWindow(), true);
+    QCOMPARE(point, QPoint());
+    // now release
+    kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
+    QCOMPARE(input()->isSelectingWindow(), false);
+    QCOMPARE(point, input()->globalPointer().toPoint());
+    QCOMPARE(input()->pointer()->window().data(), client);
+    // should give back keyboard and pointer
+    QVERIFY(pointerEnteredSpy.wait());
+    if (keyboardEnteredSpy.count() != 2) {
+        QVERIFY(keyboardEnteredSpy.wait());
+    }
+    QCOMPARE(pointerLeftSpy.count(), 1);
+    QCOMPARE(keyboardLeftSpy.count(), 1);
+    QCOMPARE(pointerEnteredSpy.count(), 2);
+    QCOMPARE(keyboardEnteredSpy.count(), 2);
+}
+
 WAYLANDTEST_MAIN(TestWindowSelection)
 #include "window_selection_test.moc"
diff --git a/autotests/mock_effectshandler.h b/autotests/mock_effectshandler.h
index 1923c7b33..1a1e05733 100644
--- a/autotests/mock_effectshandler.h
+++ b/autotests/mock_effectshandler.h
@@ -1,255 +1,258 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef MOCK_EFFECTS_HANDLER_H
 #define MOCK_EFFECTS_HANDLER_H
 
 #include <kwineffects.h>
 #include <QX11Info>
 
 class MockEffectsHandler : public KWin::EffectsHandler
 {
     Q_OBJECT
 public:
     explicit MockEffectsHandler(KWin::CompositingType type);
     void activateWindow(KWin::EffectWindow *) override {}
     KWin::Effect *activeFullScreenEffect() const {
         return nullptr;
     }
     int activeScreen() const override {
         return 0;
     }
     KWin::EffectWindow *activeWindow() const override {
         return nullptr;
     }
     void addRepaint(const QRect &) override {}
     void addRepaint(const QRegion &) override {}
     void addRepaint(int, int, int, int) override {}
     void addRepaintFull() override {}
     double animationTimeFactor() const override {
         return 0;
     }
     xcb_atom_t announceSupportProperty(const QByteArray &, KWin::Effect *) override {
         return XCB_ATOM_NONE;
     }
     void buildQuads(KWin::EffectWindow *, KWin::WindowQuadList &) override {}
     QRect clientArea(KWin::clientAreaOption, const QPoint &, int) const override {
         return QRect();
     }
     QRect clientArea(KWin::clientAreaOption, const KWin::EffectWindow *) const override {
         return QRect();
     }
     QRect clientArea(KWin::clientAreaOption, int, int) const override {
         return QRect();
     }
     void closeTabBox() override {}
     QString currentActivity() const override {
         return QString();
     }
     int currentDesktop() const override {
         return 0;
     }
     int currentTabBoxDesktop() const override {
         return 0;
     }
     QList< int > currentTabBoxDesktopList() const override {
         return QList<int>();
     }
     KWin::EffectWindow *currentTabBoxWindow() const override {
         return nullptr;
     }
     KWin::EffectWindowList currentTabBoxWindowList() const override {
         return KWin::EffectWindowList();
     }
     QPoint cursorPos() const override {
         return QPoint();
     }
     bool decorationsHaveAlpha() const override {
         return false;
     }
     bool decorationSupportsBlurBehind() const override {
         return false;
     }
     void defineCursor(Qt::CursorShape) override {}
     int desktopAbove(int, bool) const override {
         return 0;
     }
     int desktopAtCoords(QPoint) const override {
         return 0;
     }
     int desktopBelow(int, bool) const override {
         return 0;
     }
     QPoint desktopCoords(int) const override {
         return QPoint();
     }
     QPoint desktopGridCoords(int) const override {
         return QPoint();
     }
     int desktopGridHeight() const override {
         return 0;
     }
     QSize desktopGridSize() const override {
         return QSize();
     }
     int desktopGridWidth() const override {
         return 0;
     }
     QString desktopName(int) const override {
         return QString();
     }
     int desktopToLeft(int, bool) const override {
         return 0;
     }
     int desktopToRight(int, bool) const override {
         return 0;
     }
     void doneOpenGLContextCurrent() override {}
     void drawWindow(KWin::EffectWindow *, int, QRegion, KWin::WindowPaintData &) override {}
     KWin::EffectFrame *effectFrame(KWin::EffectFrameStyle, bool, const QPoint &, Qt::Alignment) const override {
         return nullptr;
     }
     KWin::EffectWindow *findWindow(WId) const override {
         return nullptr;
     }
     KWin::EffectWindow *findWindow(KWayland::Server::SurfaceInterface *) const override {
         return nullptr;
     }
     void *getProxy(QString) override {
         return nullptr;
     }
     bool grabKeyboard(KWin::Effect *) override {
         return false;
     }
     bool hasDecorationShadows() const override {
         return false;
     }
     bool isScreenLocked() const override {
         return false;
     }
     QVariant kwinOption(KWin::KWinOption) override {
         return QVariant();
     }
     bool makeOpenGLContextCurrent() override {
         return false;
     }
     void moveWindow(KWin::EffectWindow *, const QPoint &, bool, double) override {}
     KWin::WindowQuadType newWindowQuadType() override {
         return KWin::WindowQuadError;
     }
     int numberOfDesktops() const override {
         return 0;
     }
     int numScreens() const override {
         return 0;
     }
     bool optionRollOverDesktops() const override {
         return false;
     }
     void paintEffectFrame(KWin::EffectFrame *, QRegion, double, double) override {}
     void paintScreen(int, QRegion, KWin::ScreenPaintData &) override {}
     void paintWindow(KWin::EffectWindow *, int, QRegion, KWin::WindowPaintData &) override {}
     void postPaintScreen() override {}
     void postPaintWindow(KWin::EffectWindow *) override {}
     void prePaintScreen(KWin::ScreenPrePaintData &, int) override {}
     void prePaintWindow(KWin::EffectWindow *, KWin::WindowPrePaintData &, int) override {}
     QByteArray readRootProperty(long int, long int, int) const override {
         return QByteArray();
     }
     void reconfigure() override {}
     void refTabBox() override {}
     void registerAxisShortcut(Qt::KeyboardModifiers, KWin::PointerAxisDirection, QAction *) override {}
     void registerGlobalShortcut(const QKeySequence &, QAction *) override {}
     void registerPointerShortcut(Qt::KeyboardModifiers, Qt::MouseButton, QAction *) override {}
     void reloadEffect(KWin::Effect *) override {}
     void removeSupportProperty(const QByteArray &, KWin::Effect *) override {}
     void reserveElectricBorder(KWin::ElectricBorder, KWin::Effect *) override {}
     QPainter *scenePainter() override {
         return nullptr;
     }
     int screenNumber(const QPoint &) const override {
         return 0;
     }
     void setActiveFullScreenEffect(KWin::Effect *) override {}
     void setCurrentDesktop(int) override {}
     void setElevatedWindow(KWin::EffectWindow *, bool) override {}
     void setNumberOfDesktops(int) override {}
     void setShowingDesktop(bool) override {}
     void setTabBoxDesktop(int) override {}
     void setTabBoxWindow(KWin::EffectWindow*) override {}
     KWin::EffectWindowList stackingOrder() const override {
         return KWin::EffectWindowList();
     }
     void startMouseInterception(KWin::Effect *, Qt::CursorShape) override {}
     void startMousePolling() override {}
     void stopMouseInterception(KWin::Effect *) override {}
     void stopMousePolling() override {}
     void ungrabKeyboard() override {}
     void unrefTabBox() override {}
     void unreserveElectricBorder(KWin::ElectricBorder, KWin::Effect *) override {}
     QRect virtualScreenGeometry() const override {
         return QRect();
     }
     QSize virtualScreenSize() const override {
         return QSize();
     }
     void windowToDesktop(KWin::EffectWindow *, int) override {}
     void windowToScreen(KWin::EffectWindow *, int) override {}
     int workspaceHeight() const override {
         return 0;
     }
     int workspaceWidth() const override {
         return 0;
     }
     long unsigned int xrenderBufferPicture() override {
         return 0;
     }
     xcb_connection_t *xcbConnection() const override {
         return QX11Info::connection();
     }
     xcb_window_t x11RootWindow() const override {
         return QX11Info::appRootWindow();
     }
     KWayland::Server::Display *waylandDisplay() const override {
         return nullptr;
     }
 
     bool animationsSupported() const override {
         return m_animationsSuported;
     }
     void setAnimationsSupported(bool set) {
         m_animationsSuported = set;
     }
 
     KWin::PlatformCursorImage cursorImage() const override {
         return KWin::PlatformCursorImage();
     }
 
     void hideCursor() override {}
 
     void showCursor() override {}
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override {
         callback(nullptr);
     }
+    void startInteractivePositionSelection(std::function<void (const QPoint &)> callback) override {
+        callback(QPoint(-1, -1));
+    }
 
 private:
     bool m_animationsSuported = true;
 };
 #endif
diff --git a/effects.cpp b/effects.cpp
index bb5bddaea..7c51236a6 100644
--- a/effects.cpp
+++ b/effects.cpp
@@ -1,2052 +1,2057 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "effects.h"
 
 #include "effectsadaptor.h"
 #include "effectloader.h"
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "deleted.h"
 #include "client.h"
 #include "cursor.h"
 #include "group.h"
 #include "pointer_input.h"
 #include "scene_xrender.h"
 #include "scene_qpainter.h"
 #include "unmanaged.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "scripting/scriptedeffect.h"
 #include "screens.h"
 #include "screenlockerwatcher.h"
 #include "thumbnailitem.h"
 #include "virtualdesktops.h"
 #include "workspace.h"
 #include "kwinglutils.h"
 
 #include <QDebug>
 
 #include <Plasma/Theme>
 
 #include <assert.h>
 #include "composite.h"
 #include "xcbutils.h"
 #include "platform.h"
 #include "shell_client.h"
 #include "wayland_server.h"
 
 #include "decorations/decorationbridge.h"
 #include <KDecoration2/DecorationSettings>
 
 namespace KWin
 {
 //---------------------
 // Static
 
 static QByteArray readWindowProperty(xcb_window_t win, xcb_atom_t atom, xcb_atom_t type, int format)
 {
     if (win == XCB_WINDOW_NONE) {
         return QByteArray();
     }
     uint32_t len = 32768;
     for (;;) {
         Xcb::Property prop(false, win, atom, XCB_ATOM_ANY, 0, len);
         if (prop.isNull()) {
             // get property failed
             return QByteArray();
         }
         if (prop->bytes_after > 0) {
             len *= 2;
             continue;
         }
         return prop.toByteArray(format, type);
     }
 }
 
 static void deleteWindowProperty(Window win, long int atom)
 {
     if (win == XCB_WINDOW_NONE) {
         return;
     }
     xcb_delete_property(connection(), win, atom);
 }
 
 //---------------------
 
 EffectsHandlerImpl::EffectsHandlerImpl(Compositor *compositor, Scene *scene)
     : EffectsHandler(scene->compositingType())
     , keyboard_grab_effect(NULL)
     , fullscreen_effect(0)
     , next_window_quad_type(EFFECT_QUAD_TYPE_START)
     , m_compositor(compositor)
     , m_scene(scene)
     , m_desktopRendering(false)
     , m_currentRenderedDesktop(0)
     , m_effectLoader(new EffectLoader(this))
     , m_trackingCursorChanges(0)
 {
     qRegisterMetaType<QVector<KWin::EffectWindow*>>();
     connect(m_effectLoader, &AbstractEffectLoader::effectLoaded, this,
         [this](Effect *effect, const QString &name) {
             effect_order.insert(effect->requestedEffectChainPosition(), EffectPair(name, effect));
             loaded_effects << EffectPair(name, effect);
             effectsChanged();
         }
     );
     m_effectLoader->setConfig(kwinApp()->config());
     new EffectsAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Effects"), this);
     // init is important, otherwise causes crashes when quads are build before the first painting pass start
     m_currentBuildQuadsIterator = m_activeEffects.constEnd();
 
     Workspace *ws = Workspace::self();
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(ws, &Workspace::showingDesktopChanged,
             this, &EffectsHandlerImpl::showingDesktopChanged);
     connect(ws, &Workspace::currentDesktopChanged, this,
         [this](int old, AbstractClient *c) {
             const int newDesktop = VirtualDesktopManager::self()->current();
             if (old != 0 && newDesktop != old) {
                 emit desktopChanged(old, newDesktop, c ? c->effectWindow() : 0);
                 // TODO: remove in 4.10
                 emit desktopChanged(old, newDesktop);
             }
         }
     );
     connect(ws, &Workspace::desktopPresenceChanged, this,
         [this](AbstractClient *c, int old) {
             if (!c->effectWindow()) {
                 return;
             }
             // the visibility update hasn't happed yet, thus the signal is delayed to prevent glitches, see also BUG 347490
             QMetaObject::invokeMethod(this, "desktopPresenceChanged", Qt::QueuedConnection,
                                       Q_ARG(KWin::EffectWindow*, c->effectWindow()),
                                       Q_ARG(int, old),
                                       Q_ARG(int, c->desktop()));
         }
     );
     connect(ws, &Workspace::clientAdded, this,
         [this](Client *c) {
             if (c->readyForPainting())
                 slotClientShown(c);
             else
                 connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
         }
     );
     connect(ws, &Workspace::unmanagedAdded, this,
         [this](Unmanaged *u) {
             // it's never initially ready but has synthetic 50ms delay
             connect(u, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotUnmanagedShown);
         }
     );
     connect(ws, &Workspace::clientActivated, this,
         [this](KWin::AbstractClient *c) {
             emit windowActivated(c ? c->effectWindow() : nullptr);
         }
     );
     connect(ws, &Workspace::deletedRemoved, this,
         [this](KWin::Deleted *d) {
             emit windowDeleted(d->effectWindow());
             elevated_windows.removeAll(d->effectWindow());
         }
     );
     connect(vds, &VirtualDesktopManager::countChanged, this, &EffectsHandler::numberDesktopsChanged);
     connect(Cursor::self(), &Cursor::mouseChanged, this, &EffectsHandler::mouseChanged);
     connect(ws, &Workspace::propertyNotify, this,
         [this](long int atom) {
             if (!registered_atoms.contains(atom))
                 return;
             emit propertyNotify(nullptr, atom);
         }
     );
     connect(screens(), &Screens::countChanged,    this, &EffectsHandler::numberScreensChanged);
     connect(screens(), &Screens::sizeChanged,     this, &EffectsHandler::virtualScreenSizeChanged);
     connect(screens(), &Screens::geometryChanged, this, &EffectsHandler::virtualScreenGeometryChanged);
 #ifdef KWIN_BUILD_ACTIVITIES
     if (Activities *activities = Activities::self()) {
         connect(activities, &Activities::added,          this, &EffectsHandler::activityAdded);
         connect(activities, &Activities::removed,        this, &EffectsHandler::activityRemoved);
         connect(activities, &Activities::currentChanged, this, &EffectsHandler::currentActivityChanged);
     }
 #endif
     connect(ws, &Workspace::stackingOrderChanged, this, &EffectsHandler::stackingOrderChanged);
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     connect(tabBox, &TabBox::TabBox::tabBoxAdded,    this, &EffectsHandler::tabBoxAdded);
     connect(tabBox, &TabBox::TabBox::tabBoxUpdated,  this, &EffectsHandler::tabBoxUpdated);
     connect(tabBox, &TabBox::TabBox::tabBoxClosed,   this, &EffectsHandler::tabBoxClosed);
     connect(tabBox, &TabBox::TabBox::tabBoxKeyEvent, this, &EffectsHandler::tabBoxKeyEvent);
 #endif
     connect(ScreenEdges::self(), &ScreenEdges::approaching, this, &EffectsHandler::screenEdgeApproaching);
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked, this, &EffectsHandler::screenLockingChanged);
     // connect all clients
     for (Client *c : ws->clientList()) {
         setupClientConnections(c);
     }
     for (Unmanaged *u : ws->unmanagedList()) {
         setupUnmanagedConnections(u);
     }
     if (auto w = waylandServer()) {
         connect(w, &WaylandServer::shellClientAdded, this,
             [this](ShellClient *c) {
                 if (c->readyForPainting())
                     slotShellClientShown(c);
                 else
                     connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotShellClientShown);
             }
         );
     }
     reconfigure();
 }
 
 EffectsHandlerImpl::~EffectsHandlerImpl()
 {
     unloadAllEffects();
 }
 
 void EffectsHandlerImpl::unloadAllEffects()
 {
     makeOpenGLContextCurrent();
     if (keyboard_grab_effect != NULL)
         ungrabKeyboard();
     setActiveFullScreenEffect(nullptr);
     for (auto it = loaded_effects.begin(); it != loaded_effects.end(); ++it) {
         Effect *effect = (*it).second;
         stopMouseInterception(effect);
         // remove support properties for the effect
         const QList<QByteArray> properties = m_propertiesForEffects.keys();
         for (const QByteArray &property : properties) {
             removeSupportProperty(property, effect);
         }
         delete effect;
     }
     loaded_effects.clear();
     m_effectLoader->clear();
 }
 
 void EffectsHandlerImpl::setupAbstractClientConnections(AbstractClient* c)
 {
     connect(c, &AbstractClient::windowClosed, this, &EffectsHandlerImpl::slotWindowClosed);
     connect(c, static_cast<void (AbstractClient::*)(KWin::AbstractClient*, MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged),
             this, &EffectsHandlerImpl::slotClientMaximized);
     connect(c, &AbstractClient::clientStartUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowStartUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::clientStepUserMovedResized, this,
         [this](AbstractClient *c, const QRect &geometry) {
             emit windowStepUserMovedResized(c->effectWindow(), geometry);
         }
     );
     connect(c, &AbstractClient::clientFinishUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowFinishUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::opacityChanged, this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(c, &AbstractClient::clientMinimized, this,
         [this](AbstractClient *c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowMinimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::clientUnminimized, this,
         [this](AbstractClient* c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowUnminimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::modalChanged,         this, &EffectsHandlerImpl::slotClientModalityChanged);
     connect(c, &AbstractClient::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(c, &AbstractClient::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
     connect(c, &AbstractClient::windowShown, this,
         [this](Toplevel *c) {
             emit windowShown(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::windowHidden, this,
         [this](Toplevel *c) {
             emit windowHidden(c->effectWindow());
         }
     );
 }
 
 void EffectsHandlerImpl::setupClientConnections(Client* c)
 {
     setupAbstractClientConnections(c);
     connect(c, &Client::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
     connect(c, &Client::propertyNotify,       this, &EffectsHandlerImpl::slotPropertyNotify);
 }
 
 void EffectsHandlerImpl::setupUnmanagedConnections(Unmanaged* u)
 {
     connect(u, &Unmanaged::windowClosed,         this, &EffectsHandlerImpl::slotWindowClosed);
     connect(u, &Unmanaged::opacityChanged,       this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(u, &Unmanaged::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(u, &Unmanaged::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
     connect(u, &Unmanaged::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
     connect(u, &Unmanaged::propertyNotify,       this, &EffectsHandlerImpl::slotPropertyNotify);
 }
 
 void EffectsHandlerImpl::reconfigure()
 {
     m_effectLoader->queryAndLoadAll();
 }
 
 // the idea is that effects call this function again which calls the next one
 void EffectsHandlerImpl::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->prePaintScreen(data, time);
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintScreen(int mask, QRegion region, ScreenPaintData& data)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->paintScreen(mask, region, data);
         --m_currentPaintScreenIterator;
     } else
         m_scene->finalPaintScreen(mask, region, data);
 }
 
 void EffectsHandlerImpl::paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData &data)
 {
     if (desktop < 1 || desktop > numberOfDesktops()) {
         return;
     }
     m_currentRenderedDesktop = desktop;
     m_desktopRendering = true;
     // save the paint screen iterator
     EffectsIterator savedIterator = m_currentPaintScreenIterator;
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     effects->paintScreen(mask, region, data);
     // restore the saved iterator
     m_currentPaintScreenIterator = savedIterator;
     m_desktopRendering = false;
 }
 
 void EffectsHandlerImpl::postPaintScreen()
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->postPaintScreen();
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->prePaintWindow(w, data, time);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->paintWindow(w, mask, region, data);
         --m_currentPaintWindowIterator;
     } else
         m_scene->finalPaintWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity)
 {
     if (m_currentPaintEffectFrameIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintEffectFrameIterator++)->paintEffectFrame(frame, region, opacity, frameOpacity);
         --m_currentPaintEffectFrameIterator;
     } else {
         const EffectFrameImpl* frameImpl = static_cast<const EffectFrameImpl*>(frame);
         frameImpl->finalRender(region, opacity, frameOpacity);
     }
 }
 
 void EffectsHandlerImpl::postPaintWindow(EffectWindow* w)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->postPaintWindow(w);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 Effect *EffectsHandlerImpl::provides(Effect::Feature ef)
 {
     for (int i = 0; i < loaded_effects.size(); ++i)
         if (loaded_effects.at(i).second->provides(ef))
             return loaded_effects.at(i).second;
     return NULL;
 }
 
 void EffectsHandlerImpl::drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (m_currentDrawWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentDrawWindowIterator++)->drawWindow(w, mask, region, data);
         --m_currentDrawWindowIterator;
     } else
         m_scene->finalDrawWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::buildQuads(EffectWindow* w, WindowQuadList& quadList)
 {
     static bool initIterator = true;
     if (initIterator) {
         m_currentBuildQuadsIterator = m_activeEffects.constBegin();
         initIterator = false;
     }
     if (m_currentBuildQuadsIterator != m_activeEffects.constEnd()) {
         (*m_currentBuildQuadsIterator++)->buildQuads(w, quadList);
         --m_currentBuildQuadsIterator;
     }
     if (m_currentBuildQuadsIterator == m_activeEffects.constBegin())
         initIterator = true;
 }
 
 bool EffectsHandlerImpl::hasDecorationShadows() const
 {
     return false;
 }
 
 bool EffectsHandlerImpl::decorationsHaveAlpha() const
 {
     return true;
 }
 
 bool EffectsHandlerImpl::decorationSupportsBlurBehind() const
 {
     return Decoration::DecorationBridge::self()->needsBlur();
 }
 
 // start another painting pass
 void EffectsHandlerImpl::startPaint()
 {
     m_activeEffects.clear();
     m_activeEffects.reserve(loaded_effects.count());
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->isActive()) {
             m_activeEffects << it->second;
         }
     }
     m_currentDrawWindowIterator = m_activeEffects.constBegin();
     m_currentPaintWindowIterator = m_activeEffects.constBegin();
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     m_currentPaintEffectFrameIterator = m_activeEffects.constBegin();
 }
 
 void EffectsHandlerImpl::slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode)
 {
     bool horizontal = false;
     bool vertical = false;
     switch (maxMode) {
     case MaximizeHorizontal:
         horizontal = true;
         break;
     case MaximizeVertical:
         vertical = true;
         break;
     case MaximizeFull:
         horizontal = true;
         vertical = true;
         break;
     case MaximizeRestore: // fall through
     default:
         // default - nothing to do
         break;
     }
     if (EffectWindowImpl *w = c->effectWindow()) {
         emit windowMaximizedStateChanged(w, horizontal, vertical);
     }
 }
 
 void EffectsHandlerImpl::slotOpacityChanged(Toplevel *t, qreal oldOpacity)
 {
     if (t->opacity() == oldOpacity || !t->effectWindow()) {
         return;
     }
     emit windowOpacityChanged(t->effectWindow(), oldOpacity, (qreal)t->opacity());
 }
 
 void EffectsHandlerImpl::slotClientShown(KWin::Toplevel *t)
 {
     Q_ASSERT(dynamic_cast<Client*>(t));
     Client *c = static_cast<Client*>(t);
     disconnect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
     setupClientConnections(c);
     if (!c->tabGroup()) // the "window" has already been there
         emit windowAdded(c->effectWindow());
 }
 
 void EffectsHandlerImpl::slotShellClientShown(Toplevel *t)
 {
     ShellClient *c = static_cast<ShellClient*>(t);
     setupAbstractClientConnections(c);
     emit windowAdded(t->effectWindow());
 }
 
 void EffectsHandlerImpl::slotUnmanagedShown(KWin::Toplevel *t)
 {   // regardless, unmanaged windows are -yet?- not synced anyway
     Q_ASSERT(dynamic_cast<Unmanaged*>(t));
     Unmanaged *u = static_cast<Unmanaged*>(t);
     setupUnmanagedConnections(u);
     emit windowAdded(u->effectWindow());
 }
 
 void EffectsHandlerImpl::slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d)
 {
     c->disconnect(this);
     if (d) {
         emit windowClosed(c->effectWindow());
     }
 }
 
 void EffectsHandlerImpl::slotClientModalityChanged()
 {
     emit windowModalityChanged(static_cast<Client*>(sender())->effectWindow());
 }
 
 void EffectsHandlerImpl::slotCurrentTabAboutToChange(EffectWindow *from, EffectWindow *to)
 {
     emit currentTabAboutToChange(from, to);
 }
 
 void EffectsHandlerImpl::slotTabAdded(EffectWindow* w, EffectWindow* to)
 {
     emit tabAdded(w, to);
 }
 
 void EffectsHandlerImpl::slotTabRemoved(EffectWindow *w, EffectWindow* leaderOfFormerGroup)
 {
     emit tabRemoved(w, leaderOfFormerGroup);
 }
 
 void EffectsHandlerImpl::slotWindowDamaged(Toplevel* t, const QRect& r)
 {
     if (!t->effectWindow()) {
         // can happen during tear down of window
         return;
     }
     emit windowDamaged(t->effectWindow(), r);
 }
 
 void EffectsHandlerImpl::slotGeometryShapeChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == NULL || t->effectWindow() == NULL)
         return;
     emit windowGeometryShapeChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::slotPaddingChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == NULL || t->effectWindow() == NULL)
         return;
     emit windowPaddingChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::setActiveFullScreenEffect(Effect* e)
 {
     fullscreen_effect = e;
 }
 
 Effect* EffectsHandlerImpl::activeFullScreenEffect() const
 {
     return fullscreen_effect;
 }
 
 bool EffectsHandlerImpl::grabKeyboard(Effect* effect)
 {
     if (keyboard_grab_effect != NULL)
         return false;
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         bool ret = grabXKeyboard();
         if (!ret)
             return false;
     }
     keyboard_grab_effect = effect;
     return true;
 }
 
 void EffectsHandlerImpl::ungrabKeyboard()
 {
     assert(keyboard_grab_effect != NULL);
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         ungrabXKeyboard();
     }
     keyboard_grab_effect = NULL;
 }
 
 void EffectsHandlerImpl::grabbedKeyboardEvent(QKeyEvent* e)
 {
     if (keyboard_grab_effect != NULL)
         keyboard_grab_effect->grabbedKeyboardEvent(e);
 }
 
 void EffectsHandlerImpl::startMouseInterception(Effect *effect, Qt::CursorShape shape)
 {
     if (m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.append(effect);
     if (m_grabbedMouseEffects.size() != 1) {
         return;
     }
     if (kwinApp()->operationMode() != Application::OperationModeX11) {
         input()->pointer()->setEffectsOverrideCursor(shape);
         return;
     }
     // NOTE: it is intended to not perform an XPointerGrab on X11. See documentation in kwineffects.h
     // The mouse grab is implemented by using a full screen input only window
     if (!m_mouseInterceptionWindow.isValid()) {
         const QSize &s = screens()->size();
         const QRect geo(0, 0, s.width(), s.height());
         const uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
         const uint32_t values[] = {
             true,
             XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION
         };
         m_mouseInterceptionWindow.reset(Xcb::createInputWindow(geo, mask, values));
         defineCursor(shape);
     } else {
         defineCursor(shape);
     }
     m_mouseInterceptionWindow.map();
     m_mouseInterceptionWindow.raise();
     // Raise electric border windows above the input windows
     // so they can still be triggered.
     ScreenEdges::self()->ensureOnTop();
 }
 
 void EffectsHandlerImpl::stopMouseInterception(Effect *effect)
 {
     if (!m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.removeAll(effect);
     if (kwinApp()->operationMode() != Application::OperationModeX11) {
         input()->pointer()->removeEffectsOverrideCursor();
         return;
     }
     if (m_grabbedMouseEffects.isEmpty()) {
         m_mouseInterceptionWindow.unmap();
         Workspace::self()->stackScreenEdgesUnderOverrideRedirect();
     }
 }
 
 bool EffectsHandlerImpl::isMouseInterception() const
 {
     return m_grabbedMouseEffects.count() > 0;
 }
 
 
 bool EffectsHandlerImpl::touchDown(quint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchDown(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchMotion(quint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchMotion(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchUp(quint32 id, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchUp(id, time)) {
             return true;
         }
     }
     return false;
 }
 
 void EffectsHandlerImpl::registerGlobalShortcut(const QKeySequence &shortcut, QAction *action)
 {
     input()->registerShortcut(shortcut, action);
 }
 
 void EffectsHandlerImpl::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     input()->registerPointerShortcut(modifiers, pointerButtons, action);
 }
 
 void EffectsHandlerImpl::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     input()->registerAxisShortcut(modifiers, axis, action);
 }
 
 void* EffectsHandlerImpl::getProxy(QString name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name)
             return (*it).second->proxy();
 
     return NULL;
 }
 
 void EffectsHandlerImpl::startMousePolling()
 {
     if (Cursor::self())
         Cursor::self()->startMousePolling();
 }
 
 void EffectsHandlerImpl::stopMousePolling()
 {
     if (Cursor::self())
         Cursor::self()->stopMousePolling();
 }
 
 bool EffectsHandlerImpl::hasKeyboardGrab() const
 {
     return keyboard_grab_effect != NULL;
 }
 
 void EffectsHandlerImpl::desktopResized(const QSize &size)
 {
     m_scene->screenGeometryChanged(size);
     if (m_mouseInterceptionWindow.isValid()) {
         m_mouseInterceptionWindow.setGeometry(QRect(0, 0, size.width(), size.height()));
     }
     emit screenGeometryChanged(size);
 }
 
 void EffectsHandlerImpl::slotPropertyNotify(Toplevel* t, long int atom)
 {
     if (!registered_atoms.contains(atom))
         return;
     emit propertyNotify(t->effectWindow(), atom);
 }
 
 void EffectsHandlerImpl::registerPropertyType(long atom, bool reg)
 {
     if (reg)
         ++registered_atoms[ atom ]; // initialized to 0 if not present yet
     else {
         if (--registered_atoms[ atom ] == 0)
             registered_atoms.remove(atom);
     }
 }
 
 xcb_atom_t EffectsHandlerImpl::announceSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it != m_propertiesForEffects.end()) {
         // property has already been registered for an effect
         // just append Effect and return the atom stored in m_managedProperties
         if (!it.value().contains(effect)) {
             it.value().append(effect);
         }
         return m_managedProperties.value(propertyName);
     }
     // get the atom for the propertyName
     ScopedCPointer<xcb_intern_atom_reply_t> atomReply(xcb_intern_atom_reply(connection(),
         xcb_intern_atom_unchecked(connection(), false, propertyName.size(), propertyName.constData()),
         NULL));
     if (atomReply.isNull()) {
         return XCB_ATOM_NONE;
     }
     m_compositor->keepSupportProperty(atomReply->atom);
     // announce property on root window
     unsigned char dummy = 0;
     xcb_change_property(connection(), XCB_PROP_MODE_REPLACE, rootWindow(), atomReply->atom, atomReply->atom, 8, 1, &dummy);
     // TODO: add to _NET_SUPPORTED
     m_managedProperties.insert(propertyName, atomReply->atom);
     m_propertiesForEffects.insert(propertyName, QList<Effect*>() << effect);
     registerPropertyType(atomReply->atom, true);
     return atomReply->atom;
 }
 
 void EffectsHandlerImpl::removeSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it == m_propertiesForEffects.end()) {
         // property is not registered - nothing to do
         return;
     }
     if (!it.value().contains(effect)) {
         // property is not registered for given effect - nothing to do
         return;
     }
     it.value().removeAll(effect);
     if (!it.value().isEmpty()) {
         // property still registered for another effect - nothing further to do
         return;
     }
     const xcb_atom_t atom = m_managedProperties.take(propertyName);
     registerPropertyType(atom, false);
     m_propertiesForEffects.remove(propertyName);
     m_compositor->removeSupportProperty(atom); // delayed removal
 }
 
 QByteArray EffectsHandlerImpl::readRootProperty(long atom, long type, int format) const
 {
     return readWindowProperty(rootWindow(), atom, type, format);
 }
 
 void EffectsHandlerImpl::activateWindow(EffectWindow* c)
 {
     if (AbstractClient* cl = dynamic_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(c)->window()))
         Workspace::self()->activateClient(cl, true);
 }
 
 EffectWindow* EffectsHandlerImpl::activeWindow() const
 {
     return Workspace::self()->activeClient() ? Workspace::self()->activeClient()->effectWindow() : NULL;
 }
 
 void EffectsHandlerImpl::moveWindow(EffectWindow* w, const QPoint& pos, bool snap, double snapAdjust)
 {
     AbstractClient* cl = dynamic_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(w)->window());
     if (!cl || !cl->isMovable())
         return;
 
     if (snap)
         cl->move(Workspace::self()->adjustClientPosition(cl, pos, true, snapAdjust));
     else
         cl->move(pos);
 }
 
 void EffectsHandlerImpl::windowToDesktop(EffectWindow* w, int desktop)
 {
     AbstractClient* cl = dynamic_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock())
         Workspace::self()->sendClientToDesktop(cl, desktop, true);
 }
 
 void EffectsHandlerImpl::windowToScreen(EffectWindow* w, int screen)
 {
     AbstractClient* cl = dynamic_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock())
         Workspace::self()->sendClientToScreen(cl, screen);
 }
 
 void EffectsHandlerImpl::setShowingDesktop(bool showing)
 {
     Workspace::self()->setShowingDesktop(showing);
 }
 
 QString EffectsHandlerImpl::currentActivity() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return QString();
     }
     return Activities::self()->current();
 #else
     return QString();
 #endif
 }
 
 int EffectsHandlerImpl::currentDesktop() const
 {
     return VirtualDesktopManager::self()->current();
 }
 
 int EffectsHandlerImpl::numberOfDesktops() const
 {
     return VirtualDesktopManager::self()->count();
 }
 
 void EffectsHandlerImpl::setCurrentDesktop(int desktop)
 {
     VirtualDesktopManager::self()->setCurrent(desktop);
 }
 
 void EffectsHandlerImpl::setNumberOfDesktops(int desktops)
 {
     VirtualDesktopManager::self()->setCount(desktops);
 }
 
 QSize EffectsHandlerImpl::desktopGridSize() const
 {
     return VirtualDesktopManager::self()->grid().size();
 }
 
 int EffectsHandlerImpl::desktopGridWidth() const
 {
     return desktopGridSize().width();
 }
 
 int EffectsHandlerImpl::desktopGridHeight() const
 {
     return desktopGridSize().height();
 }
 
 int EffectsHandlerImpl::workspaceWidth() const
 {
     return desktopGridWidth() * displayWidth();
 }
 
 int EffectsHandlerImpl::workspaceHeight() const
 {
     return desktopGridHeight() * displayHeight();
 }
 
 int EffectsHandlerImpl::desktopAtCoords(QPoint coords) const
 {
     if (auto vd = VirtualDesktopManager::self()->grid().at(coords)) {
         return vd->x11DesktopNumber();
     }
     return 0;
 }
 
 QPoint EffectsHandlerImpl::desktopGridCoords(int id) const
 {
     return VirtualDesktopManager::self()->grid().gridCoords(id);
 }
 
 QPoint EffectsHandlerImpl::desktopCoords(int id) const
 {
     QPoint coords = VirtualDesktopManager::self()->grid().gridCoords(id);
     if (coords.x() == -1)
         return QPoint(-1, -1);
     return QPoint(coords.x() * displayWidth(), coords.y() * displayHeight());
 }
 
 int EffectsHandlerImpl::desktopAbove(int desktop, bool wrap) const
 {
     return getDesktop<DesktopAbove>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToRight(int desktop, bool wrap) const
 {
     return getDesktop<DesktopRight>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopBelow(int desktop, bool wrap) const
 {
     return getDesktop<DesktopBelow>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToLeft(int desktop, bool wrap) const
 {
     return getDesktop<DesktopLeft>(desktop, wrap);
 }
 
 QString EffectsHandlerImpl::desktopName(int desktop) const
 {
     return VirtualDesktopManager::self()->name(desktop);
 }
 
 bool EffectsHandlerImpl::optionRollOverDesktops() const
 {
     return options->isRollOverDesktops();
 }
 
 double EffectsHandlerImpl::animationTimeFactor() const
 {
     return options->animationTimeFactor();
 }
 
 WindowQuadType EffectsHandlerImpl::newWindowQuadType()
 {
     return WindowQuadType(next_window_quad_type++);
 }
 
 EffectWindow* EffectsHandlerImpl::findWindow(WId id) const
 {
     if (Client* w = Workspace::self()->findClient(Predicate::WindowMatch, id))
         return w->effectWindow();
     if (Unmanaged* w = Workspace::self()->findUnmanaged(id))
         return w->effectWindow();
     if (waylandServer()) {
         if (ShellClient *w = waylandServer()->findClient(id)) {
             return w->effectWindow();
         }
     }
     return NULL;
 }
 
 EffectWindow* EffectsHandlerImpl::findWindow(KWayland::Server::SurfaceInterface *surf) const
 {
     if (waylandServer()) {
         if (ShellClient *w = waylandServer()->findClient(surf)) {
             return w->effectWindow();
         }
     }
     return nullptr;
 }
 
 
 EffectWindowList EffectsHandlerImpl::stackingOrder() const
 {
     ToplevelList list = Workspace::self()->xStackingOrder();
     EffectWindowList ret;
     for (Toplevel *t : list) {
         if (EffectWindow *w = effectWindow(t))
             ret.append(w);
     }
     return ret;
 }
 
 void EffectsHandlerImpl::setElevatedWindow(KWin::EffectWindow* w, bool set)
 {
     elevated_windows.removeAll(w);
     if (set)
         elevated_windows.append(w);
 }
 
 void EffectsHandlerImpl::setTabBoxWindow(EffectWindow* w)
 {
 #ifdef KWIN_BUILD_TABBOX
     if (AbstractClient* c = dynamic_cast< AbstractClient* >(static_cast< EffectWindowImpl* >(w)->window())) {
         TabBox::TabBox::self()->setCurrentClient(c);
     }
 #else
     Q_UNUSED(w)
 #endif
 }
 
 void EffectsHandlerImpl::setTabBoxDesktop(int desktop)
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->setCurrentDesktop(desktop);
 #else
     Q_UNUSED(desktop)
 #endif
 }
 
 EffectWindowList EffectsHandlerImpl::currentTabBoxWindowList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     EffectWindowList ret;
     const auto clients = TabBox::TabBox::self()->currentClientList();
     for (auto c : clients)
     ret.append(c->effectWindow());
     return ret;
 #else
     return EffectWindowList();
 #endif
 }
 
 void EffectsHandlerImpl::refTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->reference();
 #endif
 }
 
 void EffectsHandlerImpl::unrefTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->unreference();
 #endif
 }
 
 void EffectsHandlerImpl::closeTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->close();
 #endif
 }
 
 QList< int > EffectsHandlerImpl::currentTabBoxDesktopList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktopList();
 #endif
     return QList< int >();
 }
 
 int EffectsHandlerImpl::currentTabBoxDesktop() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktop();
 #endif
     return -1;
 }
 
 EffectWindow* EffectsHandlerImpl::currentTabBoxWindow() const
 {
 #ifdef KWIN_BUILD_TABBOX
     if (auto c = TabBox::TabBox::self()->currentClient())
         return c->effectWindow();
 #endif
     return NULL;
 }
 
 void EffectsHandlerImpl::addRepaintFull()
 {
     m_compositor->addRepaintFull();
 }
 
 void EffectsHandlerImpl::addRepaint(const QRect& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(const QRegion& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(int x, int y, int w, int h)
 {
     m_compositor->addRepaint(x, y, w, h);
 }
 
 int EffectsHandlerImpl::activeScreen() const
 {
     return screens()->current();
 }
 
 int EffectsHandlerImpl::numScreens() const
 {
     return screens()->count();
 }
 
 int EffectsHandlerImpl::screenNumber(const QPoint& pos) const
 {
     return screens()->number(pos);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, int screen, int desktop) const
 {
     return Workspace::self()->clientArea(opt, screen, desktop);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const EffectWindow* c) const
 {
     const Toplevel* t = static_cast< const EffectWindowImpl* >(c)->window();
     if (const AbstractClient* cl = dynamic_cast< const AbstractClient* >(t))
         return Workspace::self()->clientArea(opt, cl);
     else
         return Workspace::self()->clientArea(opt, t->geometry().center(), VirtualDesktopManager::self()->current());
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const QPoint& p, int desktop) const
 {
     return Workspace::self()->clientArea(opt, p, desktop);
 }
 
 QRect EffectsHandlerImpl::virtualScreenGeometry() const
 {
     return screens()->geometry();
 }
 
 QSize EffectsHandlerImpl::virtualScreenSize() const
 {
     return screens()->size();
 }
 
 void EffectsHandlerImpl::defineCursor(Qt::CursorShape shape)
 {
     if (!m_mouseInterceptionWindow.isValid()) {
         input()->pointer()->setEffectsOverrideCursor(shape);
         return;
     }
     const xcb_cursor_t c = Cursor::x11Cursor(shape);
     if (c != XCB_CURSOR_NONE) {
         m_mouseInterceptionWindow.defineCursor(c);
     }
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(xcb_button_press_event_t *e)
 {
     if (m_grabbedMouseEffects.isEmpty() || m_mouseInterceptionWindow != e->event) {
         return false;
     }
     for (Effect *effect : m_grabbedMouseEffects) {
         Qt::MouseButton button = x11ToQtMouseButton(e->detail);
         Qt::MouseButtons buttons = x11ToQtMouseButtons(e->state);
         const QEvent::Type type = ((e->response_type & ~0x80) == XCB_BUTTON_PRESS) ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease;
         if (type == QEvent::MouseButtonPress) {
             buttons |= button;
         } else {
             buttons &= ~button;
         }
         QMouseEvent ev(type,
                         QPoint(e->event_x, e->event_y), QPoint(e->root_x, e->root_y),
                         button, buttons, x11ToQtKeyboardModifiers(e->state));
         effect->windowInputMouseEvent(&ev);
     }
     return true; // eat event
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(xcb_motion_notify_event_t *e)
 {
     if (m_grabbedMouseEffects.isEmpty() || m_mouseInterceptionWindow != e->event) {
         return false;
     }
     for (Effect *effect : m_grabbedMouseEffects) {
         QMouseEvent ev(QEvent::MouseMove, QPoint(e->event_x, e->event_y), QPoint(e->root_x, e->root_y),
                         Qt::NoButton, x11ToQtMouseButtons(e->state), x11ToQtKeyboardModifiers(e->state));
         effect->windowInputMouseEvent(&ev);
     }
     return true; // eat event
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QMouseEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QWheelEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 void EffectsHandlerImpl::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         if (!m_trackingCursorChanges) {
             connect(Cursor::self(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
             Cursor::self()->startCursorTracking();
         }
         ++m_trackingCursorChanges;
     }
     EffectsHandler::connectNotify(signal);
 }
 
 void EffectsHandlerImpl::disconnectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         Q_ASSERT(m_trackingCursorChanges > 0);
         if (!--m_trackingCursorChanges) {
             Cursor::self()->stopCursorTracking();
             disconnect(Cursor::self(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
         }
     }
     EffectsHandler::disconnectNotify(signal);
 }
 
 
 void EffectsHandlerImpl::checkInputWindowStacking()
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return;
     }
     if (kwinApp()->operationMode() != Application::OperationModeX11) {
         return;
     }
     m_mouseInterceptionWindow.raise();
     // Raise electric border windows above the input windows
     // so they can still be triggered. TODO: Do both at once.
     ScreenEdges::self()->ensureOnTop();
 }
 
 QPoint EffectsHandlerImpl::cursorPos() const
 {
     return Cursor::pos();
 }
 
 void EffectsHandlerImpl::reserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->reserve(border, effect, "borderActivated");
 }
 
 void EffectsHandlerImpl::unreserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->unreserve(border, effect);
 }
 
 unsigned long EffectsHandlerImpl::xrenderBufferPicture()
 {
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (SceneXrender* s = dynamic_cast< SceneXrender* >(m_scene))
         return s->bufferPicture();
 #endif
     return None;
 }
 
 QPainter *EffectsHandlerImpl::scenePainter()
 {
     if (SceneQPainter *s = dynamic_cast<SceneQPainter*>(m_scene)) {
         return s->painter();
     } else {
         return NULL;
     }
 }
 
 void EffectsHandlerImpl::toggleEffect(const QString& name)
 {
     if (isEffectLoaded(name))
         unloadEffect(name);
     else
         loadEffect(name);
 }
 
 QStringList EffectsHandlerImpl::loadedEffects() const
 {
     QStringList listModules;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         listModules << (*it).first;
     }
     return listModules;
 }
 
 QStringList EffectsHandlerImpl::listOfEffects() const
 {
     return m_effectLoader->listOfKnownEffects();
 }
 
 bool EffectsHandlerImpl::loadEffect(const QString& name)
 {
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->loadEffect(name);
 }
 
 void EffectsHandlerImpl::unloadEffect(const QString& name)
 {
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     for (QMap< int, EffectPair >::iterator it = effect_order.begin(); it != effect_order.end(); ++it) {
         if (it.value().first == name) {
             qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Unloading Effect : " << name;
             if (activeFullScreenEffect() == it.value().second) {
                 setActiveFullScreenEffect(0);
             }
             stopMouseInterception(it.value().second);
             // remove support properties for the effect
             const QList<QByteArray> properties = m_propertiesForEffects.keys();
             for (const QByteArray &property : properties) {
                 removeSupportProperty(property, it.value().second);
             }
             delete it.value().second;
             effect_order.erase(it);
             effectsChanged();
             return;
         }
     }
 
     qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Effect not loaded : " << name;
 }
 
 void EffectsHandlerImpl::reconfigureEffect(const QString& name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name) {
             kwinApp()->config()->reparseConfiguration();
             makeOpenGLContextCurrent();
             (*it).second->reconfigure(Effect::ReconfigureAll);
             return;
         }
 }
 
 bool EffectsHandlerImpl::isEffectLoaded(const QString& name) const
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name)
             return true;
 
     return false;
 }
 
 bool EffectsHandlerImpl::isEffectSupported(const QString &name)
 {
     // if the effect is loaded, it is obviously supported
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(), [name](const EffectPair &pair) {
         return pair.first == name;
     });
     if (it != loaded_effects.constEnd()) {
         return true;
     }
 
     // next checks might require a context
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->isEffectSupported(name);
 
 }
 
 QList< bool > EffectsHandlerImpl::areEffectsSupported(const QStringList &names)
 {
     QList< bool > retList;
     for (const QString &name : names) {
         retList << isEffectSupported(name);
     }
     return retList;
 }
 
 void EffectsHandlerImpl::reloadEffect(Effect *effect)
 {
     QString effectName;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).second == effect) {
             effectName = (*it).first;
             break;
         }
     }
     if (!effectName.isNull()) {
         unloadEffect(effectName);
         m_effectLoader->loadEffect(effectName);
     }
 }
 
 void EffectsHandlerImpl::effectsChanged()
 {
     loaded_effects.clear();
     m_activeEffects.clear(); // it's possible to have a reconfigure and a quad rebuild between two paint cycles - bug #308201
 //    qDebug() << "Recreating effects' list:";
     for (const EffectPair & effect : effect_order) {
 //        qDebug() << effect.first;
         loaded_effects.append(effect);
     }
     m_activeEffects.reserve(loaded_effects.count());
 }
 
 QStringList EffectsHandlerImpl::activeEffects() const
 {
     QStringList ret;
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(),
                                                     end = loaded_effects.constEnd(); it != end; ++it) {
             if (it->second->isActive()) {
                 ret << it->first;
             }
         }
     return ret;
 }
 
 KWayland::Server::Display *EffectsHandlerImpl::waylandDisplay() const
 {
     if (waylandServer()) {
         return waylandServer()->display();
     }
     return nullptr;
 }
 
 EffectFrame* EffectsHandlerImpl::effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const
 {
     return new EffectFrameImpl(style, staticSize, position, alignment);
 }
 
 
 QVariant EffectsHandlerImpl::kwinOption(KWinOption kwopt)
 {
     switch (kwopt) {
     case CloseButtonCorner:
         // TODO: this could become per window and be derived from the actual position in the deco
         return Decoration::DecorationBridge::self()->settings()->decorationButtonsLeft().contains(KDecoration2::DecorationButtonType::Close) ? Qt::TopLeftCorner : Qt::TopRightCorner;
     case SwitchDesktopOnScreenEdge:
         return ScreenEdges::self()->isDesktopSwitching();
     case SwitchDesktopOnScreenEdgeMovingWindows:
         return ScreenEdges::self()->isDesktopSwitchingMovingClients();
     default:
         return QVariant(); // an invalid one
     }
 }
 
 QString EffectsHandlerImpl::supportInformation(const QString &name) const
 {
     if (!isEffectLoaded(name)) {
         return QString();
     }
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == name) {
             QString support((*it).first + QLatin1String(":\n"));
             const QMetaObject *metaOptions = (*it).second->metaObject();
             for (int i=0; i<metaOptions->propertyCount(); ++i) {
                 const QMetaProperty property = metaOptions->property(i);
                 if (qstrcmp(property.name(), "objectName") == 0) {
                     continue;
                 }
                 support += QString::fromUtf8(property.name()) + QLatin1String(": ") + (*it).second->property(property.name()).toString() + QLatin1Char('\n');
             }
             return support;
         }
     }
     return QString();
 }
 
 
 bool EffectsHandlerImpl::isScreenLocked() const
 {
     return ScreenLockerWatcher::self()->isLocked();
 }
 
 QString EffectsHandlerImpl::debug(const QString& name, const QString& parameter) const
 {
     QString internalName = name.toLower();;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == internalName) {
             return it->second->debug(parameter);
         }
     }
     return QString();
 }
 
 bool EffectsHandlerImpl::makeOpenGLContextCurrent()
 {
     return m_scene->makeOpenGLContextCurrent();
 }
 
 void EffectsHandlerImpl::doneOpenGLContextCurrent()
 {
     m_scene->doneOpenGLContextCurrent();
 }
 
 bool EffectsHandlerImpl::animationsSupported() const
 {
     static const QByteArray forceEnvVar = qgetenv("KWIN_EFFECTS_FORCE_ANIMATIONS");
     if (!forceEnvVar.isEmpty()) {
         static const int forceValue = forceEnvVar.toInt();
         return forceValue == 1;
     }
     return m_scene->animationsSupported();
 }
 
 void EffectsHandlerImpl::highlightWindows(const QVector<EffectWindow *> &windows)
 {
     Effect *e = provides(Effect::HighlightWindows);
     if (!e) {
         return;
     }
     e->perform(Effect::HighlightWindows, QVariantList{QVariant::fromValue(windows)});
 }
 
 PlatformCursorImage EffectsHandlerImpl::cursorImage() const
 {
     return kwinApp()->platform()->cursorImage();
 }
 
 void EffectsHandlerImpl::hideCursor()
 {
     kwinApp()->platform()->hideCursor();
 }
 
 void EffectsHandlerImpl::showCursor()
 {
     kwinApp()->platform()->showCursor();
 }
 
 void EffectsHandlerImpl::startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback)
 {
     kwinApp()->platform()->startInteractiveWindowSelection(
         [callback] (KWin::Toplevel *t) {
             if (t && t->effectWindow()) {
                 callback(t->effectWindow());
             } else {
                 callback(nullptr);
             }
         }
     );
 }
 
+void EffectsHandlerImpl::startInteractivePositionSelection(std::function<void(const QPoint&)> callback)
+{
+    kwinApp()->platform()->startInteractivePositionSelection(callback);
+}
+
 //****************************************
 // EffectWindowImpl
 //****************************************
 
 EffectWindowImpl::EffectWindowImpl(Toplevel *toplevel)
     : EffectWindow(toplevel)
     , toplevel(toplevel)
     , sw(NULL)
 {
 }
 
 EffectWindowImpl::~EffectWindowImpl()
 {
     QVariant cachedTextureVariant = data(LanczosCacheRole);
     if (cachedTextureVariant.isValid()) {
         GLTexture *cachedTexture = static_cast< GLTexture*>(cachedTextureVariant.value<void*>());
         delete cachedTexture;
     }
 }
 
 bool EffectWindowImpl::isPaintingEnabled()
 {
     return sceneWindow()->isPaintingEnabled();
 }
 
 void EffectWindowImpl::enablePainting(int reason)
 {
     sceneWindow()->enablePainting(reason);
 }
 
 void EffectWindowImpl::disablePainting(int reason)
 {
     sceneWindow()->disablePainting(reason);
 }
 
 const EffectWindowGroup* EffectWindowImpl::group() const
 {
     if (Client* c = dynamic_cast< Client* >(toplevel))
         return c->group()->effectGroup();
     return NULL; // TODO
 }
 
 void EffectWindowImpl::refWindow()
 {
     if (Deleted* d = dynamic_cast< Deleted* >(toplevel))
         return d->refWindow();
     abort(); // TODO
 }
 
 void EffectWindowImpl::unrefWindow()
 {
     if (Deleted* d = dynamic_cast< Deleted* >(toplevel))
         return d->unrefWindow();   // delays deletion in case
     abort(); // TODO
 }
 
 void EffectWindowImpl::setWindow(Toplevel* w)
 {
     toplevel = w;
     setParent(w);
 }
 
 void EffectWindowImpl::setSceneWindow(Scene::Window* w)
 {
     sw = w;
 }
 
 QRegion EffectWindowImpl::shape() const
 {
     return sw ? sw->shape() : geometry();
 }
 
 QRect EffectWindowImpl::decorationInnerRect() const
 {
     Client *client = dynamic_cast<Client*>(toplevel);
     return client ? client->transparentRect() : contentsRect();
 }
 
 QByteArray EffectWindowImpl::readProperty(long atom, long type, int format) const
 {
     return readWindowProperty(window()->window(), atom, type, format);
 }
 
 void EffectWindowImpl::deleteProperty(long int atom) const
 {
     deleteWindowProperty(window()->window(), atom);
 }
 
 EffectWindow* EffectWindowImpl::findModal()
 {
     if (AbstractClient* c = dynamic_cast< AbstractClient* >(toplevel)) {
         if (AbstractClient* c2 = c->findModal())
             return c2->effectWindow();
     }
     return NULL;
 }
 
 template <typename T>
 EffectWindowList getMainWindows(Toplevel *toplevel)
 {
     T *c = static_cast<T*>(toplevel);
     EffectWindowList ret;
     const auto mainclients = c->mainClients();
     for (auto tmp : mainclients)
         ret.append(tmp->effectWindow());
     return ret;
 }
 
 EffectWindowList EffectWindowImpl::mainWindows() const
 {
     if (dynamic_cast<AbstractClient*>(toplevel)) {
         return getMainWindows<AbstractClient>(toplevel);
     } else if (toplevel->isDeleted()) {
         return getMainWindows<Deleted>(toplevel);
     }
     return EffectWindowList();
 }
 
 WindowQuadList EffectWindowImpl::buildQuads(bool force) const
 {
     return sceneWindow()->buildQuads(force);
 }
 
 void EffectWindowImpl::setData(int role, const QVariant &data)
 {
     if (!data.isNull())
         dataMap[ role ] = data;
     else
         dataMap.remove(role);
     emit effects->windowDataChanged(this, role);
 }
 
 QVariant EffectWindowImpl::data(int role) const
 {
     if (!dataMap.contains(role))
         return QVariant();
     return dataMap[ role ];
 }
 
 EffectWindow* effectWindow(Toplevel* w)
 {
     EffectWindowImpl* ret = w->effectWindow();
     return ret;
 }
 
 EffectWindow* effectWindow(Scene::Window* w)
 {
     EffectWindowImpl* ret = w->window()->effectWindow();
     ret->setSceneWindow(w);
     return ret;
 }
 
 void EffectWindowImpl::elevate(bool elevate)
 {
     effects->setElevatedWindow(this, elevate);
 }
 
 void EffectWindowImpl::registerThumbnail(AbstractThumbnailItem *item)
 {
     if (WindowThumbnailItem *thumb = qobject_cast<WindowThumbnailItem*>(item)) {
         insertThumbnail(thumb);
         connect(thumb, SIGNAL(destroyed(QObject*)), SLOT(thumbnailDestroyed(QObject*)));
         connect(thumb, SIGNAL(wIdChanged(qulonglong)), SLOT(thumbnailTargetChanged()));
     } else if (DesktopThumbnailItem *desktopThumb = qobject_cast<DesktopThumbnailItem*>(item)) {
         m_desktopThumbnails.append(desktopThumb);
         connect(desktopThumb, SIGNAL(destroyed(QObject*)), SLOT(desktopThumbnailDestroyed(QObject*)));
     }
 }
 
 void EffectWindowImpl::thumbnailDestroyed(QObject *object)
 {
     // we know it is a ThumbnailItem
     m_thumbnails.remove(static_cast<WindowThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::thumbnailTargetChanged()
 {
     if (WindowThumbnailItem *item = qobject_cast<WindowThumbnailItem*>(sender())) {
         insertThumbnail(item);
     }
 }
 
 void EffectWindowImpl::insertThumbnail(WindowThumbnailItem *item)
 {
     EffectWindow *w = effects->findWindow(item->wId());
     if (w) {
         m_thumbnails.insert(item, QWeakPointer<EffectWindowImpl>(static_cast<EffectWindowImpl*>(w)));
     } else {
         m_thumbnails.insert(item, QWeakPointer<EffectWindowImpl>());
     }
 }
 
 void EffectWindowImpl::desktopThumbnailDestroyed(QObject *object)
 {
     // we know it is a DesktopThumbnailItem
     m_desktopThumbnails.removeAll(static_cast<DesktopThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::referencePreviousWindowPixmap()
 {
     if (sw) {
         sw->referencePreviousPixmap();
     }
 }
 
 void EffectWindowImpl::unreferencePreviousWindowPixmap()
 {
     if (sw) {
         sw->unreferencePreviousPixmap();
     }
 }
 
 //****************************************
 // EffectWindowGroupImpl
 //****************************************
 
 
 EffectWindowList EffectWindowGroupImpl::members() const
 {
     EffectWindowList ret;
     for (Toplevel * c : group->members())
     ret.append(c->effectWindow());
     return ret;
 }
 
 //****************************************
 // EffectFrameImpl
 //****************************************
 
 EffectFrameImpl::EffectFrameImpl(EffectFrameStyle style, bool staticSize, QPoint position, Qt::Alignment alignment)
     : QObject(0)
     , EffectFrame()
     , m_style(style)
     , m_static(staticSize)
     , m_point(position)
     , m_alignment(alignment)
     , m_shader(NULL)
     , m_theme(new Plasma::Theme(this))
 {
     if (m_style == EffectFrameStyled) {
         m_frame.setImagePath(QStringLiteral("widgets/background"));
         m_frame.setCacheAllRenderedFrames(true);
         connect(m_theme, SIGNAL(themeChanged()), this, SLOT(plasmaThemeChanged()));
     }
     m_selection.setImagePath(QStringLiteral("widgets/viewitem"));
     m_selection.setElementPrefix(QStringLiteral("hover"));
     m_selection.setCacheAllRenderedFrames(true);
     m_selection.setEnabledBorders(Plasma::FrameSvg::AllBorders);
 
     m_sceneFrame = Compositor::self()->scene()->createEffectFrame(this);
 }
 
 EffectFrameImpl::~EffectFrameImpl()
 {
     delete m_sceneFrame;
 }
 
 const QFont& EffectFrameImpl::font() const
 {
     return m_font;
 }
 
 void EffectFrameImpl::setFont(const QFont& font)
 {
     if (m_font == font) {
         return;
     }
     m_font = font;
     QRect oldGeom = m_geometry;
     if (!m_text.isEmpty()) {
         autoResize();
     }
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::free()
 {
     m_sceneFrame->free();
 }
 
 const QRect& EffectFrameImpl::geometry() const
 {
     return m_geometry;
 }
 
 void EffectFrameImpl::setGeometry(const QRect& geometry, bool force)
 {
     QRect oldGeom = m_geometry;
     m_geometry = geometry;
     if (m_geometry == oldGeom && !force) {
         return;
     }
     effects->addRepaint(oldGeom);
     effects->addRepaint(m_geometry);
     if (m_geometry.size() == oldGeom.size() && !force) {
         return;
     }
 
     if (m_style == EffectFrameStyled) {
         qreal left, top, right, bottom;
         m_frame.getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         m_frame.resizeFrame(m_geometry.adjusted(-left, -top, right, bottom).size());
     }
 
     free();
 }
 
 const QIcon& EffectFrameImpl::icon() const
 {
     return m_icon;
 }
 
 void EffectFrameImpl::setIcon(const QIcon& icon)
 {
     m_icon = icon;
     if (isCrossFade()) {
         m_sceneFrame->crossFadeIcon();
     }
     if (m_iconSize.isEmpty() && !m_icon.availableSizes().isEmpty()) { // Set a size if we don't already have one
         setIconSize(m_icon.availableSizes().first());
     }
     m_sceneFrame->freeIconFrame();
 }
 
 const QSize& EffectFrameImpl::iconSize() const
 {
     return m_iconSize;
 }
 
 void EffectFrameImpl::setIconSize(const QSize& size)
 {
     if (m_iconSize == size) {
         return;
     }
     m_iconSize = size;
     autoResize();
     m_sceneFrame->freeIconFrame();
 }
 
 void EffectFrameImpl::plasmaThemeChanged()
 {
     free();
 }
 
 void EffectFrameImpl::render(QRegion region, double opacity, double frameOpacity)
 {
     if (m_geometry.isEmpty()) {
         return; // Nothing to display
     }
     m_shader = NULL;
     setScreenProjectionMatrix(static_cast<EffectsHandlerImpl*>(effects)->scene()->screenProjectionMatrix());
     effects->paintEffectFrame(this, region, opacity, frameOpacity);
 }
 
 void EffectFrameImpl::finalRender(QRegion region, double opacity, double frameOpacity) const
 {
     region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
 
     m_sceneFrame->render(region, opacity, frameOpacity);
 }
 
 Qt::Alignment EffectFrameImpl::alignment() const
 {
     return m_alignment;
 }
 
 
 void
 EffectFrameImpl::align(QRect &geometry)
 {
     if (m_alignment & Qt::AlignLeft)
         geometry.moveLeft(m_point.x());
     else if (m_alignment & Qt::AlignRight)
         geometry.moveLeft(m_point.x() - geometry.width());
     else
         geometry.moveLeft(m_point.x() - geometry.width() / 2);
     if (m_alignment & Qt::AlignTop)
         geometry.moveTop(m_point.y());
     else if (m_alignment & Qt::AlignBottom)
         geometry.moveTop(m_point.y() - geometry.height());
     else
         geometry.moveTop(m_point.y() - geometry.height() / 2);
 }
 
 
 void EffectFrameImpl::setAlignment(Qt::Alignment alignment)
 {
     m_alignment = alignment;
     align(m_geometry);
     setGeometry(m_geometry);
 }
 
 void EffectFrameImpl::setPosition(const QPoint& point)
 {
     m_point = point;
     QRect geometry = m_geometry; // this is important, setGeometry need call repaint for old & new geometry
     align(geometry);
     setGeometry(geometry);
 }
 
 const QString& EffectFrameImpl::text() const
 {
     return m_text;
 }
 
 void EffectFrameImpl::setText(const QString& text)
 {
     if (m_text == text) {
         return;
     }
     if (isCrossFade()) {
         m_sceneFrame->crossFadeText();
     }
     m_text = text;
     QRect oldGeom = m_geometry;
     autoResize();
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::setSelection(const QRect& selection)
 {
     if (selection == m_selectionGeometry) {
         return;
     }
     m_selectionGeometry = selection;
     if (m_selectionGeometry.size() != m_selection.frameSize().toSize()) {
         m_selection.resizeFrame(m_selectionGeometry.size());
     }
     // TODO; optimize to only recreate when resizing
     m_sceneFrame->freeSelection();
 }
 
 void EffectFrameImpl::autoResize()
 {
     if (m_static)
         return; // Not automatically resizing
 
     QRect geometry;
     // Set size
     if (!m_text.isEmpty()) {
         QFontMetrics metrics(m_font);
         geometry.setSize(metrics.size(0, m_text));
     }
     if (!m_icon.isNull() && !m_iconSize.isEmpty()) {
         geometry.setLeft(-m_iconSize.width());
         if (m_iconSize.height() > geometry.height())
             geometry.setHeight(m_iconSize.height());
     }
 
     align(geometry);
     setGeometry(geometry);
 }
 
 QColor EffectFrameImpl::styledTextColor()
 {
     return m_theme->color(Plasma::Theme::TextColor);
 }
 
 } // namespace
diff --git a/effects.h b/effects.h
index b4ed46963..58e4f7ce3 100644
--- a/effects.h
+++ b/effects.h
@@ -1,524 +1,525 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_EFFECTSIMPL_H
 #define KWIN_EFFECTSIMPL_H
 
 #include "kwineffects.h"
 
 #include "client.h"
 #include "scene.h"
 #include "xcbutils.h"
 
 #include <QHash>
 #include <Plasma/FrameSvg>
 
 namespace Plasma {
 class Theme;
 }
 
 namespace KWayland
 {
 namespace Server
 {
 class Display;
 }
 }
 
 class QDBusPendingCallWatcher;
 class QDBusServiceWatcher;
 
 
 namespace KWin
 {
 
 class AbstractThumbnailItem;
 class DesktopThumbnailItem;
 class WindowThumbnailItem;
 
 class Client;
 class Compositor;
 class Deleted;
 class EffectLoader;
 class Unmanaged;
 
 class KWIN_EXPORT EffectsHandlerImpl : public EffectsHandler
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
     Q_PROPERTY(QStringList activeEffects READ activeEffects)
     Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
     Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
 public:
     EffectsHandlerImpl(Compositor *compositor, Scene *scene);
     virtual ~EffectsHandlerImpl();
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, QRegion region, ScreenPaintData& data) override;
     /**
      * Special hook to perform a paintScreen but just with the windows on @p desktop.
      **/
     void paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData& data);
     void postPaintScreen() override;
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) override;
     void postPaintWindow(EffectWindow* w) override;
     void paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity) override;
 
     Effect *provides(Effect::Feature ef);
 
     void drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) override;
 
     void buildQuads(EffectWindow* w, WindowQuadList& quadList) override;
 
     void activateWindow(EffectWindow* c) override;
     EffectWindow* activeWindow() const override;
     void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) override;
     void windowToDesktop(EffectWindow* w, int desktop) override;
     void windowToScreen(EffectWindow* w, int screen) override;
     void setShowingDesktop(bool showing) override;
 
     QString currentActivity() const override;
     int currentDesktop() const override;
     int numberOfDesktops() const override;
     void setCurrentDesktop(int desktop) override;
     void setNumberOfDesktops(int desktops) override;
     QSize desktopGridSize() const override;
     int desktopGridWidth() const override;
     int desktopGridHeight() const override;
     int workspaceWidth() const override;
     int workspaceHeight() const override;
     int desktopAtCoords(QPoint coords) const override;
     QPoint desktopGridCoords(int id) const override;
     QPoint desktopCoords(int id) const override;
     int desktopAbove(int desktop = 0, bool wrap = true) const override;
     int desktopToRight(int desktop = 0, bool wrap = true) const override;
     int desktopBelow(int desktop = 0, bool wrap = true) const override;
     int desktopToLeft(int desktop = 0, bool wrap = true) const override;
     QString desktopName(int desktop) const override;
     bool optionRollOverDesktops() const override;
 
     QPoint cursorPos() const override;
     bool grabKeyboard(Effect* effect) override;
     void ungrabKeyboard() override;
     // not performing XGrabPointer
     void startMouseInterception(Effect *effect, Qt::CursorShape shape) override;
     void stopMouseInterception(Effect *effect) override;
     bool isMouseInterception() const;
     void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) override;
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) override;
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) override;
     void* getProxy(QString name) override;
     void startMousePolling() override;
     void stopMousePolling() override;
     EffectWindow* findWindow(WId id) const override;
     EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const override;
     EffectWindowList stackingOrder() const override;
     void setElevatedWindow(KWin::EffectWindow* w, bool set) override;
 
     void setTabBoxWindow(EffectWindow*) override;
     void setTabBoxDesktop(int) override;
     EffectWindowList currentTabBoxWindowList() const override;
     void refTabBox() override;
     void unrefTabBox() override;
     void closeTabBox() override;
     QList< int > currentTabBoxDesktopList() const override;
     int currentTabBoxDesktop() const override;
     EffectWindow* currentTabBoxWindow() const override;
 
     void setActiveFullScreenEffect(Effect* e) override;
     Effect* activeFullScreenEffect() const override;
 
     void addRepaintFull() override;
     void addRepaint(const QRect& r) override;
     void addRepaint(const QRegion& r) override;
     void addRepaint(int x, int y, int w, int h) override;
     int activeScreen() const override;
     int numScreens() const override;
     int screenNumber(const QPoint& pos) const override;
     QRect clientArea(clientAreaOption, int screen, int desktop) const override;
     QRect clientArea(clientAreaOption, const EffectWindow* c) const override;
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const override;
     QSize virtualScreenSize() const override;
     QRect virtualScreenGeometry() const override;
     double animationTimeFactor() const override;
     WindowQuadType newWindowQuadType() override;
 
     void defineCursor(Qt::CursorShape shape) override;
     bool checkInputWindowEvent(xcb_button_press_event_t *e);
     bool checkInputWindowEvent(xcb_motion_notify_event_t *e);
     bool checkInputWindowEvent(QMouseEvent *e);
     bool checkInputWindowEvent(QWheelEvent *e);
     void checkInputWindowStacking();
 
     void reserveElectricBorder(ElectricBorder border, Effect *effect) override;
     void unreserveElectricBorder(ElectricBorder border, Effect *effect) override;
 
     unsigned long xrenderBufferPicture() override;
     QPainter* scenePainter() override;
     void reconfigure() override;
     QByteArray readRootProperty(long atom, long type, int format) const override;
     xcb_atom_t announceSupportProperty(const QByteArray& propertyName, Effect* effect) override;
     void removeSupportProperty(const QByteArray& propertyName, Effect* effect) override;
 
     bool hasDecorationShadows() const override;
 
     bool decorationsHaveAlpha() const override;
 
     bool decorationSupportsBlurBehind() const override;
 
     EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const override;
 
     QVariant kwinOption(KWinOption kwopt) override;
     bool isScreenLocked() const override;
 
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
 
     xcb_connection_t *xcbConnection() const override;
     xcb_window_t x11RootWindow() const override;
 
     // internal (used by kwin core or compositing code)
     void startPaint();
     void grabbedKeyboardEvent(QKeyEvent* e);
     bool hasKeyboardGrab() const;
     void desktopResized(const QSize &size);
 
     void reloadEffect(Effect *effect) override;
     QStringList loadedEffects() const;
     QStringList listOfEffects() const;
     void unloadAllEffects();
 
     QList<EffectWindow*> elevatedWindows() const;
     QStringList activeEffects() const;
 
     /**
      * @returns Whether we are currently in a desktop rendering process triggered by paintDesktop hook
      **/
     bool isDesktopRendering() const {
         return m_desktopRendering;
     }
     /**
      * @returns the desktop currently being rendered in the paintDesktop hook.
      **/
     int currentRenderedDesktop() const {
         return m_currentRenderedDesktop;
     }
 
     KWayland::Server::Display *waylandDisplay() const override;
 
     bool animationsSupported() const override;
 
     PlatformCursorImage cursorImage() const override;
 
     void hideCursor() override;
     void showCursor() override;
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override;
+    void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) override;
 
     Scene *scene() const {
         return m_scene;
     }
 
     bool touchDown(quint32 id, const QPointF &pos, quint32 time);
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time);
     bool touchUp(quint32 id, quint32 time);
 
     void highlightWindows(const QVector<EffectWindow *> &windows);
 
 public Q_SLOTS:
     void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to);
     void slotTabAdded(EffectWindow* from, EffectWindow* to);
     void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow);
 
     // slots for D-Bus interface
     Q_SCRIPTABLE void reconfigureEffect(const QString& name);
     Q_SCRIPTABLE bool loadEffect(const QString& name);
     Q_SCRIPTABLE void toggleEffect(const QString& name);
     Q_SCRIPTABLE void unloadEffect(const QString& name);
     Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const;
     Q_SCRIPTABLE bool isEffectSupported(const QString& name);
     Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
     Q_SCRIPTABLE QString supportInformation(const QString& name) const;
     Q_SCRIPTABLE QString debug(const QString& name, const QString& parameter = QString()) const;
 
 protected Q_SLOTS:
     void slotClientShown(KWin::Toplevel*);
     void slotShellClientShown(KWin::Toplevel*);
     void slotUnmanagedShown(KWin::Toplevel*);
     void slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d);
     void slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode);
     void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity);
     void slotClientModalityChanged();
     void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old);
     void slotPaddingChanged(KWin::Toplevel *t, const QRect &old);
     void slotWindowDamaged(KWin::Toplevel *t, const QRect& r);
     void slotPropertyNotify(KWin::Toplevel *t, long atom);
 
 protected:
     void connectNotify(const QMetaMethod &signal) override;
     void disconnectNotify(const QMetaMethod &signal) override;
     void effectsChanged();
     void setupAbstractClientConnections(KWin::AbstractClient *c);
     void setupClientConnections(KWin::Client *c);
     void setupUnmanagedConnections(KWin::Unmanaged *u);
 
     Effect* keyboard_grab_effect;
     Effect* fullscreen_effect;
     QList<EffectWindow*> elevated_windows;
     QMultiMap< int, EffectPair > effect_order;
     QHash< long, int > registered_atoms;
     int next_window_quad_type;
 
 private:
     void registerPropertyType(long atom, bool reg);
     typedef QVector< Effect*> EffectsList;
     typedef EffectsList::const_iterator EffectsIterator;
     EffectsList m_activeEffects;
     EffectsIterator m_currentDrawWindowIterator;
     EffectsIterator m_currentPaintWindowIterator;
     EffectsIterator m_currentPaintEffectFrameIterator;
     EffectsIterator m_currentPaintScreenIterator;
     EffectsIterator m_currentBuildQuadsIterator;
     typedef QHash< QByteArray, QList< Effect*> > PropertyEffectMap;
     PropertyEffectMap m_propertiesForEffects;
     QHash<QByteArray, qulonglong> m_managedProperties;
     Compositor *m_compositor;
     Scene *m_scene;
     bool m_desktopRendering;
     int m_currentRenderedDesktop;
     Xcb::Window m_mouseInterceptionWindow;
     QList<Effect*> m_grabbedMouseEffects;
     EffectLoader *m_effectLoader;
     int m_trackingCursorChanges;
 };
 
 class EffectWindowImpl : public EffectWindow
 {
     Q_OBJECT
 public:
     explicit EffectWindowImpl(Toplevel *toplevel);
     virtual ~EffectWindowImpl();
 
     void enablePainting(int reason) override;
     void disablePainting(int reason) override;
     bool isPaintingEnabled() override;
 
     void refWindow() override;
     void unrefWindow() override;
 
     const EffectWindowGroup* group() const override;
 
     QRegion shape() const override;
     QRect decorationInnerRect() const override;
     QByteArray readProperty(long atom, long type, int format) const override;
     void deleteProperty(long atom) const override;
 
     EffectWindow* findModal() override;
     EffectWindowList mainWindows() const override;
 
     WindowQuadList buildQuads(bool force = false) const override;
 
     void referencePreviousWindowPixmap() override;
     void unreferencePreviousWindowPixmap() override;
 
     const Toplevel* window() const;
     Toplevel* window();
 
     void setWindow(Toplevel* w);   // internal
     void setSceneWindow(Scene::Window* w);   // internal
     const Scene::Window* sceneWindow() const; // internal
     Scene::Window* sceneWindow(); // internal
 
     void elevate(bool elevate);
 
     void setData(int role, const QVariant &data);
     QVariant data(int role) const;
 
     void registerThumbnail(AbstractThumbnailItem *item);
     QHash<WindowThumbnailItem*, QWeakPointer<EffectWindowImpl> > const &thumbnails() const {
         return m_thumbnails;
     }
     QList<DesktopThumbnailItem*> const &desktopThumbnails() const {
         return m_desktopThumbnails;
     }
 private Q_SLOTS:
     void thumbnailDestroyed(QObject *object);
     void thumbnailTargetChanged();
     void desktopThumbnailDestroyed(QObject *object);
 private:
     void insertThumbnail(WindowThumbnailItem *item);
     Toplevel* toplevel;
     Scene::Window* sw; // This one is used only during paint pass.
     QHash<int, QVariant> dataMap;
     QHash<WindowThumbnailItem*, QWeakPointer<EffectWindowImpl> > m_thumbnails;
     QList<DesktopThumbnailItem*> m_desktopThumbnails;
 };
 
 class EffectWindowGroupImpl
     : public EffectWindowGroup
 {
 public:
     explicit EffectWindowGroupImpl(Group* g);
     EffectWindowList members() const override;
 private:
     Group* group;
 };
 
 class EffectFrameImpl
     : public QObject, public EffectFrame
 {
     Q_OBJECT
 public:
     explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1),
                              Qt::Alignment alignment = Qt::AlignCenter);
     virtual ~EffectFrameImpl();
 
     void free() override;
     void render(QRegion region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) override;
     Qt::Alignment alignment() const override;
     void setAlignment(Qt::Alignment alignment) override;
     const QFont& font() const override;
     void setFont(const QFont& font) override;
     const QRect& geometry() const override;
     void setGeometry(const QRect& geometry, bool force = false) override;
     const QIcon& icon() const override;
     void setIcon(const QIcon& icon) override;
     const QSize& iconSize() const override;
     void setIconSize(const QSize& size) override;
     void setPosition(const QPoint& point) override;
     const QString& text() const override;
     void setText(const QString& text) override;
     EffectFrameStyle style() const override {
         return m_style;
     };
     Plasma::FrameSvg& frame() {
         return m_frame;
     }
     bool isStatic() const {
         return m_static;
     };
     void finalRender(QRegion region, double opacity, double frameOpacity) const;
     void setShader(GLShader* shader) override {
         m_shader = shader;
     }
     GLShader* shader() const override {
         return m_shader;
     }
     void setSelection(const QRect& selection) override;
     const QRect& selection() const {
         return m_selectionGeometry;
     }
     Plasma::FrameSvg& selectionFrame() {
         return m_selection;
     }
     /**
      * The foreground text color as specified by the default Plasma theme.
      */
     QColor styledTextColor();
 
 private Q_SLOTS:
     void plasmaThemeChanged();
 
 private:
     Q_DISABLE_COPY(EffectFrameImpl)   // As we need to use Qt slots we cannot copy this class
     void align(QRect &geometry);   // positions geometry around m_point respecting m_alignment
     void autoResize(); // Auto-resize if not a static size
 
     EffectFrameStyle m_style;
     Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames
     Plasma::FrameSvg m_selection;
 
     // Position
     bool m_static;
     QPoint m_point;
     Qt::Alignment m_alignment;
     QRect m_geometry;
 
     // Contents
     QString m_text;
     QFont m_font;
     QIcon m_icon;
     QSize m_iconSize;
     QRect m_selectionGeometry;
 
     Scene::EffectFrame* m_sceneFrame;
     GLShader* m_shader;
 
     Plasma::Theme *m_theme;
 };
 
 inline
 QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
 {
     if (isScreenLocked())
         return QList<EffectWindow*>();
     return elevated_windows;
 }
 
 inline
 xcb_window_t EffectsHandlerImpl::x11RootWindow() const
 {
     return rootWindow();
 }
 
 inline
 xcb_connection_t *EffectsHandlerImpl::xcbConnection() const
 {
     return connection();
 }
 
 inline
 EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g)
     : group(g)
 {
 }
 
 EffectWindow* effectWindow(Toplevel* w);
 EffectWindow* effectWindow(Scene::Window* w);
 
 inline
 const Scene::Window* EffectWindowImpl::sceneWindow() const
 {
     return sw;
 }
 
 inline
 Scene::Window* EffectWindowImpl::sceneWindow()
 {
     return sw;
 }
 
 inline
 const Toplevel* EffectWindowImpl::window() const
 {
     return toplevel;
 }
 
 inline
 Toplevel* EffectWindowImpl::window()
 {
     return toplevel;
 }
 
 
 } // namespace
 
 #endif
diff --git a/effects/screenshot/screenshot.cpp b/effects/screenshot/screenshot.cpp
index 9f7da1cd7..0eae92bce 100644
--- a/effects/screenshot/screenshot.cpp
+++ b/effects/screenshot/screenshot.cpp
@@ -1,554 +1,645 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
  Copyright (C) 2010 Martin Gräßlin <mgraesslin@kde.org>
  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "screenshot.h"
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 #include <kwinxrenderutils.h>
 #include <QtConcurrentRun>
 #include <QDataStream>
 #include <QtCore/QTemporaryFile>
 #include <QtCore/QDir>
 #include <QtDBus/QDBusConnection>
 #include <QVarLengthArray>
 #include <QtGui/QPainter>
 #include <QMatrix4x4>
 #include <xcb/xcb_image.h>
 
 #include <KLocalizedString>
 #include <KNotification>
 
 #include <unistd.h>
 
 namespace KWin
 {
 
 bool ScreenShotEffect::supported()
 {
     return  effects->compositingType() == XRenderCompositing ||
             (effects->isOpenGLCompositing() && GLRenderTarget::supported());
 }
 
 ScreenShotEffect::ScreenShotEffect()
     : m_scheduledScreenshot(0)
     , m_replyConnection(QDBusConnection::sessionBus())
 {
     connect ( effects, SIGNAL(windowClosed(KWin::EffectWindow*)), SLOT(windowClosed(KWin::EffectWindow*)) );
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/Screenshot"), this, QDBusConnection::ExportScriptableContents);
     QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kwin.Screenshot"));
 }
 
 ScreenShotEffect::~ScreenShotEffect()
 {
     QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/Screenshot"));
     QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.kde.kwin.Screenshot"));
 }
 
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 static QImage xPictureToImage(xcb_render_picture_t srcPic, const QRect &geometry, xcb_image_t **xImage)
 {
     xcb_connection_t *c = effects->xcbConnection();
     xcb_pixmap_t xpix = xcb_generate_id(c);
     xcb_create_pixmap(c, 32, xpix, effects->x11RootWindow(), geometry.width(), geometry.height());
     XRenderPicture pic(xpix, 32);
     xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, srcPic, XCB_RENDER_PICTURE_NONE, pic,
                          geometry.x(), geometry.y(), 0, 0, 0, 0, geometry.width(), geometry.height());
     xcb_flush(c);
     *xImage = xcb_image_get(c, xpix, 0, 0, geometry.width(), geometry.height(), ~0, XCB_IMAGE_FORMAT_Z_PIXMAP);
     QImage img((*xImage)->data, (*xImage)->width, (*xImage)->height, (*xImage)->stride, QImage::Format_ARGB32_Premultiplied);
     // TODO: byte order might need swapping
     xcb_free_pixmap(c, xpix);
     return img.copy();
 }
 #endif
 
 void ScreenShotEffect::paintScreen(int mask, QRegion region, ScreenPaintData &data)
 {
     m_cachedOutputGeometry = data.outputGeometry();
     effects->paintScreen(mask, region, data);
 
     if (m_infoFrame) {
         m_infoFrame->render(region);
     }
 }
 
 void ScreenShotEffect::postPaintScreen()
 {
     effects->postPaintScreen();
     if (m_scheduledScreenshot) {
         WindowPaintData d(m_scheduledScreenshot);
         double left = 0;
         double top = 0;
         double right = m_scheduledScreenshot->width();
         double bottom = m_scheduledScreenshot->height();
         if (m_scheduledScreenshot->hasDecoration() && m_type & INCLUDE_DECORATION) {
             foreach (const WindowQuad & quad, d.quads) {
                 // we need this loop to include the decoration padding
                 left   = qMin(left, quad.left());
                 top    = qMin(top, quad.top());
                 right  = qMax(right, quad.right());
                 bottom = qMax(bottom, quad.bottom());
             }
         } else if (m_scheduledScreenshot->hasDecoration()) {
             WindowQuadList newQuads;
             left = m_scheduledScreenshot->width();
             top = m_scheduledScreenshot->height();
             right = 0;
             bottom = 0;
             foreach (const WindowQuad & quad, d.quads) {
                 if (quad.type() == WindowQuadContents) {
                     newQuads << quad;
                     left   = qMin(left, quad.left());
                     top    = qMin(top, quad.top());
                     right  = qMax(right, quad.right());
                     bottom = qMax(bottom, quad.bottom());
                 }
             }
             d.quads = newQuads;
         }
         const int width = right - left;
         const int height = bottom - top;
         bool validTarget = true;
         QScopedPointer<GLTexture> offscreenTexture;
         QScopedPointer<GLRenderTarget> target;
         if (effects->isOpenGLCompositing()) {
             offscreenTexture.reset(new GLTexture(GL_RGBA8, width, height));
             offscreenTexture->setFilter(GL_LINEAR);
             offscreenTexture->setWrapMode(GL_CLAMP_TO_EDGE);
             target.reset(new GLRenderTarget(*offscreenTexture));
             validTarget = target->valid();
         }
         if (validTarget) {
             d.setXTranslation(-m_scheduledScreenshot->x() - left);
             d.setYTranslation(-m_scheduledScreenshot->y() - top);
 
             // render window into offscreen texture
             int mask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_TRANSLUCENT;
             QImage img;
             if (effects->isOpenGLCompositing()) {
                 GLRenderTarget::pushRenderTarget(target.data());
                 glClearColor(0.0, 0.0, 0.0, 0.0);
                 glClear(GL_COLOR_BUFFER_BIT);
                 glClearColor(0.0, 0.0, 0.0, 1.0);
 
                 QMatrix4x4 projection;
                 projection.ortho(QRect(0, 0, offscreenTexture->width(), offscreenTexture->height()));
                 d.setProjectionMatrix(projection);
 
                 effects->drawWindow(m_scheduledScreenshot, mask, infiniteRegion(), d);
 
                 // copy content from framebuffer into image
                 img = QImage(QSize(width, height), QImage::Format_ARGB32);
                 glReadnPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, img.byteCount(), (GLvoid*)img.bits());
                 GLRenderTarget::popRenderTarget();
                 ScreenShotEffect::convertFromGLImage(img, width, height);
             }
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
             xcb_image_t *xImage = NULL;
             if (effects->compositingType() == XRenderCompositing) {
                 setXRenderOffscreen(true);
                 effects->drawWindow(m_scheduledScreenshot, mask, QRegion(0, 0, width, height), d);
                 if (xRenderOffscreenTarget()) {
                     img = xPictureToImage(xRenderOffscreenTarget(), QRect(0, 0, width, height), &xImage);
                 }
                 setXRenderOffscreen(false);
             }
 #endif
 
             if (m_type & INCLUDE_CURSOR) {
                 grabPointerImage(img, m_scheduledScreenshot->x() + left, m_scheduledScreenshot->y() + top);
             }
 
             if (m_windowMode == WindowMode::Xpixmap) {
                 const int depth = img.depth();
                 xcb_pixmap_t xpix = xcb_generate_id(xcbConnection());
                 xcb_create_pixmap(xcbConnection(), depth, xpix, x11RootWindow(), img.width(), img.height());
 
                 xcb_gcontext_t cid = xcb_generate_id(xcbConnection());
                 xcb_create_gc(xcbConnection(), cid, xpix, 0, NULL);
                 xcb_put_image(xcbConnection(), XCB_IMAGE_FORMAT_Z_PIXMAP, xpix, cid, img.width(), img.height(),
                             0, 0, 0, depth, img.byteCount(), img.constBits());
                 xcb_free_gc(xcbConnection(), cid);
                 xcb_flush(xcbConnection());
                 emit screenshotCreated(xpix);
                 m_windowMode = WindowMode::NoCapture;
             } else if (m_windowMode == WindowMode::File) {
                 sendReplyImage(img);
             } else if (m_windowMode == WindowMode::FileDescriptor) {
                 QtConcurrent::run(
                     [] (int fd, const QImage &img) {
                         QFile file;
                         if (file.open(fd, QIODevice::WriteOnly, QFileDevice::AutoCloseHandle)) {
                             QDataStream ds(&file);
                             ds << img;
                             file.close();
                         } else {
                             close(fd);
                         }
                     }, m_fd, img);
                 m_windowMode = WindowMode::NoCapture;
                 m_fd = -1;
             }
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
             if (xImage) {
                 xcb_image_destroy(xImage);
             }
 #endif
         }
         m_scheduledScreenshot = NULL;
     }
 
     if (!m_scheduledGeometry.isNull()) {
         if (!m_cachedOutputGeometry.isNull()) {
             // special handling for per-output geometry rendering
             const QRect intersection = m_scheduledGeometry.intersected(m_cachedOutputGeometry);
             if (intersection.isEmpty()) {
                 // doesn't intersect, not going onto this screenshot
                 return;
             }
             const QImage img = blitScreenshot(intersection);
             if (img.size() == m_scheduledGeometry.size()) {
                 // we are done
                 sendReplyImage(img);
                 return;
             }
             if (m_multipleOutputsImage.isNull()) {
                 m_multipleOutputsImage = QImage(m_scheduledGeometry.size(), QImage::Format_ARGB32);
                 m_multipleOutputsImage.fill(Qt::transparent);
             }
             QPainter p;
             p.begin(&m_multipleOutputsImage);
             p.drawImage(intersection.topLeft() - m_scheduledGeometry.topLeft(), img);
             p.end();
             m_multipleOutputsRendered = m_multipleOutputsRendered.united(intersection);
             if (m_multipleOutputsRendered.boundingRect() == m_scheduledGeometry) {
                 sendReplyImage(m_multipleOutputsImage);
             }
 
         } else {
             const QImage img = blitScreenshot(m_scheduledGeometry);
             sendReplyImage(img);
         }
     }
 }
 
 void ScreenShotEffect::sendReplyImage(const QImage &img)
 {
-    m_replyConnection.send(m_replyMessage.createReply(saveTempImage(img)));
+    if (m_fd != -1) {
+        QtConcurrent::run(
+            [] (int fd, const QImage &img) {
+                QFile file;
+                if (file.open(fd, QIODevice::WriteOnly, QFileDevice::AutoCloseHandle)) {
+                    QDataStream ds(&file);
+                    ds << img;
+                    file.close();
+                } else {
+                    close(fd);
+                }
+            }, m_fd, img);
+        m_fd = -1;
+    } else {
+        m_replyConnection.send(m_replyMessage.createReply(saveTempImage(img)));
+    }
     m_scheduledGeometry = QRect();
     m_multipleOutputsImage = QImage();
     m_multipleOutputsRendered = QRegion();
     m_captureCursor = false;
     m_windowMode = WindowMode::NoCapture;
 }
 
 QString ScreenShotEffect::saveTempImage(const QImage &img)
 {
     if (img.isNull()) {
         return QString();
     }
     QTemporaryFile temp(QDir::tempPath() + QDir::separator() + QLatin1String("kwin_screenshot_XXXXXX.png"));
     temp.setAutoRemove(false);
     if (!temp.open()) {
         return QString();
     }
     img.save(&temp);
     temp.close();
     KNotification::event(KNotification::Notification,
                         i18nc("Notification caption that a screenshot got saved to file", "Screenshot"),
                         i18nc("Notification with path to screenshot file", "Screenshot saved to %1", temp.fileName()),
                         QStringLiteral("spectacle"));
     return temp.fileName();
 }
 
 void ScreenShotEffect::screenshotWindowUnderCursor(int mask)
 {
     m_type = (ScreenShotType)mask;
     const QPoint cursor = effects->cursorPos();
     EffectWindowList order = effects->stackingOrder();
     EffectWindowList::const_iterator it = order.constEnd(), first = order.constBegin();
     while( it != first ) {
         m_scheduledScreenshot = *(--it);
         if (m_scheduledScreenshot->isOnCurrentDesktop() &&
             !m_scheduledScreenshot->isMinimized() && !m_scheduledScreenshot->isDeleted() &&
             m_scheduledScreenshot->geometry().contains(cursor))
             break;
         m_scheduledScreenshot = 0;
     }
     if (m_scheduledScreenshot) {
         m_scheduledScreenshot->addRepaintFull();
     }
 }
 
 void ScreenShotEffect::screenshotForWindow(qulonglong winid, int mask)
 {
     m_type = (ScreenShotType) mask;
     EffectWindow* w = effects->findWindow(winid);
     if(w && !w->isMinimized() && !w->isDeleted()) {
         m_windowMode = WindowMode::Xpixmap;
         m_scheduledScreenshot = w;
         m_scheduledScreenshot->addRepaintFull();
     }
 }
 
 QString ScreenShotEffect::interactive(int mask)
 {
     if (!calledFromDBus()) {
         return QString();
     }
     if (!m_scheduledGeometry.isNull() || m_windowMode != WindowMode::NoCapture) {
         sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
         return QString();
     }
     m_type = (ScreenShotType) mask;
     m_windowMode = WindowMode::File;
     m_replyConnection = connection();
     m_replyMessage = message();
     setDelayedReply(true);
     effects->startInteractiveWindowSelection(
         [this] (EffectWindow *w) {
             hideInfoMessage();
             if (!w) {
                 m_replyConnection.send(m_replyMessage.createErrorReply(QDBusError::Failed, "Screenshot got cancelled"));
                 m_windowMode = WindowMode::NoCapture;
                 return;
             } else {
                 m_scheduledScreenshot = w;
                 m_scheduledScreenshot->addRepaintFull();
             }
     });
 
-    showInfoMessage();
+    showInfoMessage(InfoMessageMode::Window);
     return QString();
 }
 
 void ScreenShotEffect::interactive(QDBusUnixFileDescriptor fd, int mask)
 {
     if (!calledFromDBus()) {
         return;
     }
     if (!m_scheduledGeometry.isNull() || m_windowMode != WindowMode::NoCapture) {
         sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
         return;
     }
     m_fd = dup(fd.fileDescriptor());
     if (m_fd == -1) {
         sendErrorReply(QDBusError::Failed, "No valid file descriptor");
         return;
     }
     m_type = (ScreenShotType) mask;
     m_windowMode = WindowMode::FileDescriptor;
 
     effects->startInteractiveWindowSelection(
         [this] (EffectWindow *w) {
             hideInfoMessage();
             if (!w) {
                 close(m_fd);
                 m_fd = -1;
                 m_windowMode = WindowMode::NoCapture;
                 return;
             } else {
                 m_scheduledScreenshot = w;
                 m_scheduledScreenshot->addRepaintFull();
             }
     });
 
-    showInfoMessage();
+    showInfoMessage(InfoMessageMode::Window);
 }
 
-void ScreenShotEffect::showInfoMessage()
+void ScreenShotEffect::showInfoMessage(InfoMessageMode mode)
 {
     if (!m_infoFrame.isNull()) {
         return;
     }
     m_infoFrame.reset(effects->effectFrame(EffectFrameStyled, false));
     QFont font;
     font.setBold(true);
     m_infoFrame->setFont(font);
     QRect area = effects->clientArea(ScreenArea, effects->activeScreen(), effects->currentDesktop());
     m_infoFrame->setPosition(QPoint(area.x() + area.width() / 2, area.y() + area.height() / 3));
-    m_infoFrame->setText(i18n("Select window to screen shot with left click or enter.\nEscape or right click to cancel."));
+    switch (mode) {
+    case InfoMessageMode::Window:
+        m_infoFrame->setText(i18n("Select window to screen shot with left click or enter.\nEscape or right click to cancel."));
+        break;
+    case InfoMessageMode::Screen:
+        m_infoFrame->setText(i18n("Create screen shot with left click or enter.\nEscape or right click to cancel."));
+        break;
+    }
     effects->addRepaintFull();
 }
 
 void ScreenShotEffect::hideInfoMessage()
 {
     m_infoFrame.reset();
 }
 
 QString ScreenShotEffect::screenshotFullscreen(bool captureCursor)
 {
     if (!calledFromDBus()) {
         return QString();
     }
     if (!m_scheduledGeometry.isNull()) {
         sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
         return QString();
     }
     m_replyConnection = connection();
     m_replyMessage = message();
     setDelayedReply(true);
     m_scheduledGeometry = effects->virtualScreenGeometry();
     m_captureCursor = captureCursor;
     effects->addRepaintFull();
     return QString();
 }
 
+void ScreenShotEffect::screenshotFullscreen(QDBusUnixFileDescriptor fd, bool captureCursor)
+{
+    if (!calledFromDBus()) {
+        return;
+    }
+    if (!m_scheduledGeometry.isNull()) {
+        sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
+        return;
+    }
+    m_fd = dup(fd.fileDescriptor());
+    if (m_fd == -1) {
+        sendErrorReply(QDBusError::Failed, "No valid file descriptor");
+        return;
+    }
+    m_captureCursor = captureCursor;
+
+    showInfoMessage(InfoMessageMode::Screen);
+    effects->startInteractivePositionSelection(
+        [this] (const QPoint &p) {
+            hideInfoMessage();
+            if (p == QPoint(-1, -1)) {
+                // error condition
+                close(m_fd);
+                m_fd = -1;
+            } else {
+                m_scheduledGeometry = effects->virtualScreenGeometry();
+                effects->addRepaint(m_scheduledGeometry);
+            }
+        }
+    );
+}
+
 QString ScreenShotEffect::screenshotScreen(int screen, bool captureCursor)
 {
     if (!calledFromDBus()) {
         return QString();
     }
     if (!m_scheduledGeometry.isNull()) {
         sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
         return QString();
     }
     m_scheduledGeometry = effects->clientArea(FullScreenArea, screen, 0);
     if (m_scheduledGeometry.isNull()) {
         sendErrorReply(QDBusError::Failed, "Invalid screen requested");
         return QString();
     }
     m_captureCursor = captureCursor;
     m_replyConnection = connection();
     m_replyMessage = message();
     setDelayedReply(true);
     effects->addRepaint(m_scheduledGeometry);
     return QString();
 }
 
+void ScreenShotEffect::screenshotScreen(QDBusUnixFileDescriptor fd, bool captureCursor)
+{
+    if (!calledFromDBus()) {
+        return;
+    }
+    if (!m_scheduledGeometry.isNull()) {
+        sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
+        return;
+    }
+    m_fd = dup(fd.fileDescriptor());
+    if (m_fd == -1) {
+        sendErrorReply(QDBusError::Failed, "No valid file descriptor");
+        return;
+    }
+    m_captureCursor = captureCursor;
+
+    showInfoMessage(InfoMessageMode::Screen);
+    effects->startInteractivePositionSelection(
+        [this] (const QPoint &p) {
+            hideInfoMessage();
+            if (p == QPoint(-1, -1)) {
+                // error condition
+                close(m_fd);
+                m_fd = -1;
+            } else {
+                m_scheduledGeometry = effects->clientArea(FullScreenArea, effects->screenNumber(p), 0);
+                if (m_scheduledGeometry.isNull()) {
+                    close(m_fd);
+                    m_fd = -1;
+                    return;
+                }
+                effects->addRepaint(m_scheduledGeometry);
+            }
+        }
+    );
+}
+
 QString ScreenShotEffect::screenshotArea(int x, int y, int width, int height, bool captureCursor)
 {
     if (!calledFromDBus()) {
         return QString();
     }
     if (!m_scheduledGeometry.isNull()) {
         sendErrorReply(QDBusError::Failed, "A screenshot is already been taken");
         return QString();
     }
     m_scheduledGeometry = QRect(x, y, width, height);
     if (m_scheduledGeometry.isNull() || m_scheduledGeometry.isEmpty()) {
         m_scheduledGeometry = QRect();
         sendErrorReply(QDBusError::Failed, "Invalid area requested");
         return QString();
     }
     m_captureCursor = captureCursor;
     m_replyConnection = connection();
     m_replyMessage = message();
     setDelayedReply(true);
     effects->addRepaint(m_scheduledGeometry);
     return QString();
 }
 
 QImage ScreenShotEffect::blitScreenshot(const QRect &geometry)
 {
     QImage img;
     if (effects->isOpenGLCompositing())
     {
         if (!GLRenderTarget::blitSupported()) {
             qCDebug(KWINEFFECTS) << "Framebuffer Blit not supported";
             return img;
         }
         GLTexture tex(GL_RGBA8, geometry.width(), geometry.height());
         GLRenderTarget target(tex);
         target.blitFromFramebuffer(geometry);
         // copy content from framebuffer into image
         tex.bind();
         img = QImage(geometry.size(), QImage::Format_ARGB32);
         if (GLPlatform::instance()->isGLES()) {
             glReadPixels(0, 0, img.width(), img.height(), GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
         } else {
             glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
         }
         tex.unbind();
         ScreenShotEffect::convertFromGLImage(img, geometry.width(), geometry.height());
     }
 
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (effects->compositingType() == XRenderCompositing) {
     xcb_image_t *xImage = NULL;
         img = xPictureToImage(effects->xrenderBufferPicture(), geometry, &xImage);
         if (xImage) {
             xcb_image_destroy(xImage);
         }
     }
 #endif
 
     if (m_captureCursor) {
         grabPointerImage(img, geometry.x(), geometry.y());
     }
 
     return img;
 }
 
 void ScreenShotEffect::grabPointerImage(QImage& snapshot, int offsetx, int offsety)
 {
     const auto cursor = effects->cursorImage();
     if (cursor.image().isNull())
         return;
 
     QPainter painter(&snapshot);
     painter.drawImage(effects->cursorPos() - cursor.hotSpot() - QPoint(offsetx, offsety), cursor.image());
 }
 
 void ScreenShotEffect::convertFromGLImage(QImage &img, int w, int h)
 {
     // from QtOpenGL/qgl.cpp
     // Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
     // see http://qt.gitorious.org/qt/qt/blobs/master/src/opengl/qgl.cpp
     if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
         // OpenGL gives RGBA; Qt wants ARGB
         uint *p = (uint*)img.bits();
         uint *end = p + w * h;
         while (p < end) {
             uint a = *p << 24;
             *p = (*p >> 8) | a;
             p++;
         }
     } else {
         // OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
         for (int y = 0; y < h; y++) {
             uint *q = (uint*)img.scanLine(y);
             for (int x = 0; x < w; ++x) {
                 const uint pixel = *q;
                 *q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
                      | (pixel & 0xff00ff00);
 
                 q++;
             }
         }
 
     }
     img = img.mirrored();
 }
 
 bool ScreenShotEffect::isActive() const
 {
     return (m_scheduledScreenshot != NULL || !m_scheduledGeometry.isNull() || !m_infoFrame.isNull()) && !effects->isScreenLocked();
 }
 
 void ScreenShotEffect::windowClosed( EffectWindow* w )
 {
     if (w == m_scheduledScreenshot) {
         m_scheduledScreenshot = NULL;
         screenshotWindowUnderCursor(m_type);
     }
 }
 
 } // namespace
diff --git a/effects/screenshot/screenshot.h b/effects/screenshot/screenshot.h
index 8a54aa563..8a2b5c84d 100644
--- a/effects/screenshot/screenshot.h
+++ b/effects/screenshot/screenshot.h
@@ -1,143 +1,174 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
  Copyright (C) 2010 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SCREENSHOT_H
 #define KWIN_SCREENSHOT_H
 
 #include <kwineffects.h>
 #include <QDBusContext>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusUnixFileDescriptor>
 #include <QObject>
 #include <QImage>
 
 namespace KWin
 {
 
 class ScreenShotEffect : public Effect, protected QDBusContext
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Screenshot")
 public:
     enum ScreenShotType {
         INCLUDE_DECORATION = 1 << 0,
         INCLUDE_CURSOR = 1 << 1
     };
     ScreenShotEffect();
     virtual ~ScreenShotEffect();
     void paintScreen(int mask, QRegion region, ScreenPaintData &data) override;
     virtual void postPaintScreen();
     virtual bool isActive() const;
 
     int requestedEffectChainPosition() const override {
         return 50;
     }
 
     static bool supported();
     static void convertFromGLImage(QImage &img, int w, int h);
 public Q_SLOTS:
     Q_SCRIPTABLE void screenshotForWindow(qulonglong winid, int mask = 0);
     /**
      * Starts an interactive window screenshot session. The user can select a window to
      * screenshot.
      *
      * Once the window is selected the screenshot is saved into a file and the path gets
      * returned to the DBus peer.
      *
      * @param mask The mask for what to include in the screenshot
      **/
     Q_SCRIPTABLE QString interactive(int mask = 0);
     /**
      * Starts an interactive window screenshot session. The user can select a window to
      * screenshot.
      *
      * Once the window is selected the screenshot is saved into the @p fd passed to the
      * method. It is intended to be used with a pipe, so that the invoking side can just
      * read from the pipe. The image gets written into the fd using a QDataStream.
      *
      * @param fd File descriptor into which the screenshot should be saved
      * @param mask The mask for what to include in the screenshot
      **/
     Q_SCRIPTABLE void interactive(QDBusUnixFileDescriptor fd, int mask = 0);
     Q_SCRIPTABLE void screenshotWindowUnderCursor(int mask = 0);
     /**
      * Saves a screenshot of all screen into a file and returns the path to the file.
      * Functionality requires hardware support, if not available a null string is returned.
      * @param captureCursor Whether to include the cursor in the image
      * @returns Path to stored screenshot, or null string in failure case.
      **/
     Q_SCRIPTABLE QString screenshotFullscreen(bool captureCursor = false);
+    /**
+     * Starts an interactive screenshot session.
+     *
+     * The user is asked to confirm that a screenshot is taken by having to actively
+     * click and giving the possibility to cancel.
+     *
+     * Once the screenshot is taken it gets saved into the @p fd passed to the
+     * method. It is intended to be used with a pipe, so that the invoking side can just
+     * read from the pipe. The image gets written into the fd using a QDataStream.
+     *
+     * @param fd File descriptor into which the screenshot should be saved
+     * @param captureCursor Whether to include the mouse cursor
+     **/
+    Q_SCRIPTABLE void screenshotFullscreen(QDBusUnixFileDescriptor fd, bool captureCursor = false);
     /**
      * Saves a screenshot of the screen identified by @p screen into a file and returns the path to the file.
      * Functionality requires hardware support, if not available a null string is returned.
      * @param screen Number of screen as numbered by QDesktopWidget
      * @param captureCursor Whether to include the cursor in the image
      * @returns Path to stored screenshot, or null string in failure case.
      **/
     Q_SCRIPTABLE QString screenshotScreen(int screen, bool captureCursor = false);
+    /**
+     * Starts an interactive screenshot of a screen session.
+     *
+     * The user is asked to select the screen to screenshot.
+     *
+     * Once the screenshot is taken it gets saved into the @p fd passed to the
+     * method. It is intended to be used with a pipe, so that the invoking side can just
+     * read from the pipe. The image gets written into the fd using a QDataStream.
+     *
+     * @param fd File descriptor into which the screenshot should be saved
+     * @param captureCursor Whether to include the mouse cursor
+     **/
+    Q_SCRIPTABLE void screenshotScreen(QDBusUnixFileDescriptor fd, bool captureCursor = false);
     /**
      * Saves a screenshot of the selected geometry into a file and returns the path to the file.
      * Functionality requires hardware support, if not available a null string is returned.
      * @param x Left upper x coord of region
      * @param y Left upper y coord of region
      * @param width Width of the region to screenshot
      * @param height Height of the region to screenshot
      * @param captureCursor Whether to include the cursor in the image
      * @returns Path to stored screenshot, or null string in failure case.
      **/
     Q_SCRIPTABLE QString screenshotArea(int x, int y, int width, int height, bool captureCursor = false);
 
 Q_SIGNALS:
     Q_SCRIPTABLE void screenshotCreated(qulonglong handle);
 
 private Q_SLOTS:
     void windowClosed( KWin::EffectWindow* w );
 
 private:
     void grabPointerImage(QImage& snapshot, int offsetx, int offsety);
     QImage blitScreenshot(const QRect &geometry);
     QString saveTempImage(const QImage &img);
     void sendReplyImage(const QImage &img);
-    void showInfoMessage();
+    enum class InfoMessageMode {
+        Window,
+        Screen
+    };
+    void showInfoMessage(InfoMessageMode mode);
     void hideInfoMessage();
     EffectWindow *m_scheduledScreenshot;
     ScreenShotType m_type;
     QRect m_scheduledGeometry;
     QDBusConnection m_replyConnection;
     QDBusMessage m_replyMessage;
     QRect m_cachedOutputGeometry;
     QImage m_multipleOutputsImage;
     QRegion m_multipleOutputsRendered;
     bool m_captureCursor = false;
     enum class WindowMode {
         NoCapture,
         Xpixmap,
         File,
         FileDescriptor
     };
     WindowMode m_windowMode = WindowMode::NoCapture;
     int m_fd = -1;
     QScopedPointer<EffectFrame> m_infoFrame;
 };
 
 } // namespace
 
 #endif // KWIN_SCREENSHOT_H
diff --git a/input.cpp b/input.cpp
index c55ac3a8d..bdce5000b 100644
--- a/input.cpp
+++ b/input.cpp
@@ -1,1875 +1,1903 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "input.h"
 #include "input_event.h"
 #include "keyboard_input.h"
 #include "pointer_input.h"
 #include "touch_input.h"
 #include "client.h"
 #include "effects.h"
 #include "globalshortcuts.h"
 #include "logind.h"
 #include "main.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox/tabbox.h"
 #endif
 #include "unmanaged.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "workspace.h"
 #if HAVE_INPUT
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #endif
 #include "platform.h"
 #include "shell_client.h"
 #include "wayland_server.h"
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/fakeinput_interface.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/relativepointer_interface.h>
 #include <decorations/decoratedclient.h>
 #include <KDecoration2/Decoration>
 //screenlocker
 #include <KScreenLocker/KsldApp>
 // Qt
 #include <QKeyEvent>
 
 #include <xkbcommon/xkbcommon.h>
 
 namespace KWin
 {
 
 InputEventFilter::InputEventFilter() = default;
 
 InputEventFilter::~InputEventFilter()
 {
     if (input()) {
         input()->uninstallInputEventFilter(this);
     }
 }
 
 bool InputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     return false;
 }
 
 bool InputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::keyEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::touchDown(quint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchMotion(quint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchUp(quint32 id, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(scale)
     Q_UNUSED(angleDelta)
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 void InputEventFilter::passToWaylandServer(QKeyEvent *event)
 {
     Q_ASSERT(waylandServer());
     if (event->isAutoRepeat()) {
         return;
     }
     switch (event->type()) {
     case QEvent::KeyPress:
         waylandServer()->seat()->keyPressed(event->nativeScanCode());
         break;
     case QEvent::KeyRelease:
         waylandServer()->seat()->keyReleased(event->nativeScanCode());
         break;
     default:
         break;
     }
 }
 
 #if HAVE_INPUT
 class VirtualTerminalFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         // really on press and not on release? X11 switches on press.
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             const xkb_keysym_t keysym = event->nativeVirtualKey();
             if (keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12) {
                 LogindIntegration::self()->switchVirtualTerminal(keysym - XKB_KEY_XF86Switch_VT_1 + 1);
                 return true;
             }
         }
         return false;
     }
 };
 #endif
 
 class TerminateServerFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             if (event->nativeVirtualKey() == XKB_KEY_Terminate_Server) {
                 qCWarning(KWIN_CORE) << "Request to terminate server";
                 QMetaObject::invokeMethod(qApp, "quit", Qt::QueuedConnection);
                 return true;
             }
         }
         return false;
     }
 };
 
 class LockScreenFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (event->type() == QEvent::MouseMove) {
             if (event->buttons() == Qt::NoButton) {
                 // update pointer window only if no button is pressed
                 input()->pointer()->update();
             }
             if (pointerSurfaceAllowed()) {
                 seat->setPointerPos(event->screenPos().toPoint());
             }
         } else if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonRelease) {
             if (pointerSurfaceAllowed()) {
                 event->type() == QEvent::MouseButtonPress ? seat->pointerButtonPressed(nativeButton) : seat->pointerButtonReleased(nativeButton);
             }
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         if (pointerSurfaceAllowed()) {
             seat->setTimestamp(event->timestamp());
             const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
             seat->pointerAxis(orientation, orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y());
         }
         return true;
     }
     bool keyEvent(QKeyEvent * event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // wayland client takes care of it
             return true;
         }
         // send event to KSldApp for global accel
         // if event is set to accepted it means a whitelisted shortcut was triggered
         // in that case we filter it out and don't process it further
         event->setAccepted(false);
         QCoreApplication::sendEvent(ScreenLocker::KSldApp::self(), event);
         if (event->isAccepted()) {
             return true;
         }
 
         // continue normal processing
         input()->keyboard()->update();
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (!keyboardSurfaceAllowed()) {
             // don't pass event to seat
             return true;
         }
         switch (event->type()) {
         case QEvent::KeyPress:
             seat->keyPressed(event->nativeScanCode());
             break;
         case QEvent::KeyRelease:
             seat->keyReleased(event->nativeScanCode());
             break;
         default:
             break;
         }
         return true;
     }
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (!seat->isTouchSequence()) {
             input()->touch()->update(pos);
         }
         if (touchSurfaceAllowed()) {
             input()->touch()->insertId(id, seat->touchDown(pos));
         }
         return true;
     }
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchMove(kwaylandId, pos);
             }
         }
         return true;
     }
     bool touchUp(quint32 id, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchUp(kwaylandId);
                 input()->touch()->removeId(id);
             }
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         Q_UNUSED(scale)
         Q_UNUSED(angleDelta)
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 private:
     bool surfaceAllowed(KWayland::Server::SurfaceInterface *(KWayland::Server::SeatInterface::*method)() const) const {
         if (KWayland::Server::SurfaceInterface *s = (waylandServer()->seat()->*method)()) {
             if (Toplevel *t = waylandServer()->findClient(s)) {
                 return t->isLockScreen() || t->isInputMethod();
             }
             return false;
         }
         return true;
     }
     bool pointerSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedPointerSurface);
     }
     bool keyboardSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedKeyboardSurface);
     }
     bool touchSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedTouchSurface);
     }
 };
 
 class EffectsFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!effects) {
             return false;
         }
         return static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!effects || !static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(event);
         return true;
     }
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchDown(id, pos, time);
     }
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchMotion(id, pos, time);
     }
     bool touchUp(quint32 id, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchUp(id, time);
     }
 };
 
 class MoveResizeFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         AbstractClient *c = workspace()->getMovingClient();
         if (!c) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseMove:
             c->updateMoveResize(event->screenPos().toPoint());
             break;
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 c->endMoveResize();
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while moving a window
         return workspace()->getMovingClient() != nullptr;
     }
     bool keyEvent(QKeyEvent *event) override {
         AbstractClient *c = workspace()->getMovingClient();
         if (!c) {
             return false;
         }
         if (event->type() == QEvent::KeyPress) {
             c->keyPressEvent(event->key() | event->modifiers());
             if (c->isMove() || c->isResize()) {
                 // only update if mode didn't end
                 c->updateMoveResize(input()->globalPointer());
             }
         }
         return true;
     }
 };
 
 class WindowSelectorFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!m_active) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 if (event->button() == Qt::RightButton) {
                     cancel();
                 } else {
                     accept();
                 }
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while selecting a window
         return m_active;
     }
     bool keyEvent(QKeyEvent *event) override {
         Q_UNUSED(event)
         if (!m_active) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             // x11 variant does this on key press, so do the same
             if (event->key() == Qt::Key_Escape) {
                 cancel();
             } else if (event->key() == Qt::Key_Enter ||
                        event->key() == Qt::Key_Return ||
                        event->key() == Qt::Key_Space) {
                 accept();
             }
             if (input()->supportsPointerWarping()) {
                 int mx = 0;
                 int my = 0;
                 if (event->key() == Qt::Key_Left) {
                     mx = -10;
                 }
                 if (event->key() == Qt::Key_Right) {
                     mx = 10;
                 }
                 if (event->key() == Qt::Key_Up) {
                     my = -10;
                 }
                 if (event->key() == Qt::Key_Down) {
                     my = 10;
                 }
                 if (event->modifiers() & Qt::ControlModifier) {
                     mx /= 10;
                     my /= 10;
                 }
                 input()->warpPointer(input()->globalPointer() + QPointF(mx, my));
             }
         }
         // filter out while selecting a window
         return true;
     }
 
     bool isActive() const {
         return m_active;
     }
     void start(std::function<void(KWin::Toplevel*)> callback) {
         Q_ASSERT(!m_active);
         m_active = true;
         m_callback = callback;
         input()->keyboard()->update();
     }
+    void start(std::function<void(const QPoint &)> callback) {
+        Q_ASSERT(!m_active);
+        m_active = true;
+        m_pointSelectionFallback = callback;
+        input()->keyboard()->update();
+    }
 private:
     void deactivate() {
         m_active = false;
         m_callback = std::function<void(KWin::Toplevel*)>();
+        m_pointSelectionFallback = std::function<void(const QPoint &)>();
         input()->pointer()->removeWindowSelectionCursor();
         input()->keyboard()->update();
     }
     void cancel() {
-        m_callback(nullptr);
+        if (m_callback) {
+            m_callback(nullptr);
+        }
+        if (m_pointSelectionFallback) {
+            m_pointSelectionFallback(QPoint(-1, -1));
+        }
         deactivate();
     }
     void accept() {
-        // TODO: this ignores shaped windows
-        m_callback(input()->findToplevel(input()->globalPointer().toPoint()));
+        if (m_callback) {
+            // TODO: this ignores shaped windows
+            m_callback(input()->findToplevel(input()->globalPointer().toPoint()));
+        }
+        if (m_pointSelectionFallback) {
+            m_pointSelectionFallback(input()->globalPointer().toPoint());
+        }
         deactivate();
     }
     bool m_active = false;
     std::function<void(KWin::Toplevel*)> m_callback;
+    std::function<void(const QPoint &)> m_pointSelectionFallback;
 };
 
 class GlobalShortcutFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton);
         if (event->type() == QEvent::MouseButtonPress) {
             if (input()->shortcuts()->processPointerPressed(event->modifiers(), event->buttons())) {
                 return true;
             }
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->modifiers() == Qt::NoModifier) {
             return false;
         }
         PointerAxisDirection direction = PointerAxisUp;
         if (event->angleDelta().x() < 0) {
             direction = PointerAxisRight;
         } else if (event->angleDelta().x() > 0) {
             direction = PointerAxisLeft;
         } else if (event->angleDelta().y() < 0) {
             direction = PointerAxisDown;
         } else if (event->angleDelta().y() > 0) {
             direction = PointerAxisUp;
         }
         return input()->shortcuts()->processAxis(event->modifiers(), direction);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (event->type() == QEvent::KeyPress) {
             return input()->shortcuts()->processKey(input()->keyboard()->xkb()->modifiersRelevantForGlobalShortcuts(), event->nativeVirtualKey(), event->key());
         }
         return false;
     }
 };
 
 class InternalWindowEventFilter : public InputEventFilter {
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         if (event->buttons() == Qt::NoButton) {
             // update pointer window only if no button is pressed
             input()->pointer()->update();
         }
         if (!internal) {
             return false;
         }
         QMouseEvent e(event->type(),
                         event->pos() - internal->position(),
                         event->globalPos(),
                         event->button(), event->buttons(), event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         const QPointF localPos = event->globalPosF() - QPointF(internal->x(), internal->y());
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta() * -1,
                         delta * -1,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool keyEvent(QKeyEvent *event) override {
         const auto &internalClients = waylandServer()->internalClients();
         if (internalClients.isEmpty()) {
             return false;
         }
         QWindow *found = nullptr;
         auto it = internalClients.end();
         do {
             it--;
             if (QWindow *w = (*it)->internalWindow()) {
                 if (!w->isVisible()) {
                     continue;
                 }
                 if (!screens()->geometry().contains(w->geometry())) {
                     continue;
                 }
                 if (w->property("_q_showWithoutActivating").toBool()) {
                     continue;
                 }
                 found = w;
                 break;
             }
         } while (it != internalClients.begin());
         if (!found) {
             return false;
         }
         event->setAccepted(false);
         if (QCoreApplication::sendEvent(found, event)) {
             waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
             passToWaylandServer(event);
             return true;
         }
         return false;
     }
 
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             // something else is getting the events
             return false;
         }
         auto touch = input()->touch();
         if (touch->internalPressId() != -1) {
             // already on a decoration, ignore further touch points, but filter out
             return true;
         }
         // a new touch point
         seat->setTimestamp(time);
         touch->update(pos);
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         touch->setInternalPressId(id);
         // Qt's touch event API is rather complex, let's do fake mouse events instead
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return true;
     }
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
         QMouseEvent e(QEvent::MouseMove, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         QCoreApplication::instance()->sendEvent(internal.data(), &e);
         return true;
     }
     bool touchUp(quint32 id, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setInternalPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 class DecorationEventFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         const QPointF p = event->globalPos() - decoration->client()->pos();
         switch (event->type()) {
         case QEvent::MouseMove: {
             if (event->buttons() == Qt::NoButton) {
                 return false;
             }
             QHoverEvent e(QEvent::HoverMove, p, p);
             QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
             decoration->client()->processDecorationMove(p.toPoint(), event->globalPos());
             return true;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease: {
             QMouseEvent e(event->type(), p, event->globalPos(), event->button(), event->buttons(), event->modifiers());
             e.setAccepted(false);
             QCoreApplication::sendEvent(decoration->decoration(), &e);
             if (!e.isAccepted() && event->type() == QEvent::MouseButtonPress) {
                 decoration->client()->processDecorationButtonPress(&e);
             }
             if (event->type() == QEvent::MouseButtonRelease) {
                 decoration->client()->processDecorationButtonRelease(&e);
             }
             return true;
         }
         default:
             break;
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         const QPointF localPos = event->globalPosF() - decoration->client()->pos();
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta(),
                         delta,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration.data(), &e);
         if (e.isAccepted()) {
             return true;
         }
         if ((orientation == Qt::Vertical) && decoration->client()->titlebarPositionUnderMouse()) {
             decoration->client()->performMouseCommand(options->operationTitlebarMouseWheel(delta * -1),
                                                         event->globalPosF().toPoint());
         }
         return true;
     }
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         if (input()->touch()->decorationPressId() != -1) {
             // already on a decoration, ignore further touch points, but filter out
             return true;
         }
         seat->setTimestamp(time);
         input()->touch()->update(pos);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         input()->touch()->setDecorationPressId(id);
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         if (!e.isAccepted()) {
             decoration->client()->processDecorationButtonPress(&e);
         }
         return true;
     }
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
         QHoverEvent e(QEvent::HoverMove, m_lastLocalTouchPos, m_lastLocalTouchPos);
         QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationMove(m_lastLocalTouchPos.toPoint(), pos.toPoint());
         return true;
     }
     bool touchUp(quint32 id, quint32 time) override {
         Q_UNUSED(time);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationButtonRelease(&e);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setDecorationPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 #ifdef KWIN_BUILD_TABBOX
 class TabBoxInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 button) override {
         Q_UNUSED(button)
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleMouseEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setFocusedKeyboardSurface(nullptr);
         // pass the key event to the seat, so that it has a proper model of the currently hold keys
         // this is important for combinations like alt+shift to ensure that shift is not considered pressed
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             TabBox::TabBox::self()->keyPress(event->modifiers() | event->key());
         } else if (input()->keyboard()->xkb()->modifiersRelevantForGlobalShortcuts() == Qt::NoModifier) {
             TabBox::TabBox::self()->modifiersReleased();
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleWheelEvent(event);
     }
 };
 #endif
 
 class ScreenEdgeInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         ScreenEdges::self()->isEntered(event);
         // always forward
         return false;
     }
 };
 
 /**
  * This filter implements window actions. If the event should not be passed to the
  * current pointer window it will filter out the event
  **/
 class WindowActionInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (event->type() != QEvent::MouseButtonPress) {
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->window().data());
         if (!c) {
             return false;
         }
         bool wasAction = false;
         Options::MouseCommand command = Options::MouseNothing;
         if (input()->keyboard()->xkb()->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
             wasAction = true;
             switch (event->button()) {
             case Qt::LeftButton:
                 command = options->commandAll1();
                 break;
             case Qt::MiddleButton:
                 command = options->commandAll2();
                 break;
             case Qt::RightButton:
                 command = options->commandAll3();
                 break;
             default:
                 // nothing
                 break;
             }
         } else {
             command = c->getMouseCommand(event->button(), &wasAction);
         }
         if (wasAction) {
             return !c->performMouseCommand(command, event->globalPos());
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->angleDelta().y() == 0) {
             // only actions on vertical scroll
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->window().data());
         if (!c) {
             return false;
         }
         bool wasAction = false;
         Options::MouseCommand command = Options::MouseNothing;
         if (input()->keyboard()->xkb()->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
             wasAction = true;
             command = options->operationWindowMouseWheel(-1 * event->angleDelta().y());
         } else {
             command = c->getWheelCommand(Qt::Vertical, &wasAction);
         }
         if (wasAction) {
             return !c->performMouseCommand(command, event->globalPos());
         }
         return false;
     }
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(id)
         Q_UNUSED(time)
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         input()->touch()->update(pos);
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->touch()->window().data());
         if (!c) {
             return false;
         }
         bool wasAction = false;
         const Options::MouseCommand command = c->getMouseCommand(Qt::LeftButton, &wasAction);
         if (wasAction) {
             return !c->performMouseCommand(command, pos.toPoint());
         }
         return false;
     }
 };
 
 /**
  * The remaining default input filter which forwards events to other windows
  **/
 class ForwardInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             if (event->buttons() == Qt::NoButton) {
                 // update pointer window only if no button is pressed
                 input()->pointer()->update();
             }
             seat->setPointerPos(event->globalPos());
             MouseEvent *e = static_cast<MouseEvent*>(event);
             if (e->delta() != QSizeF()) {
                 seat->relativePointerMotion(e->delta(), e->deltaUnaccelerated(), e->timestampMicroseconds());
             }
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             if (event->buttons() == Qt::NoButton) {
                 input()->pointer()->update();
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
         seat->pointerAxis(orientation, orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y());
         return true;
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!workspace()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // handled by Wayland client
             return false;
         }
         auto seat = waylandServer()->seat();
         input()->keyboard()->update();
         seat->setTimestamp(event->timestamp());
         passToWaylandServer(event);
         return true;
     }
     bool touchDown(quint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (!seat->isTouchSequence()) {
             input()->touch()->update(pos);
         }
         input()->touch()->insertId(id, seat->touchDown(pos));
         return true;
     }
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchMove(kwaylandId, pos);
         }
         return true;
     }
     bool touchUp(quint32 id, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchUp(kwaylandId);
             input()->touch()->removeId(id);
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerPinchGesture(fingerCount);
         return true;
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerPinchGesture(delta, scale, angleDelta);
         return true;
     }
     bool pinchGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerPinchGesture();
         return true;
     }
     bool pinchGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerPinchGesture();
         return true;
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerSwipeGesture(fingerCount);
         return true;
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerSwipeGesture(delta);
         return true;
     }
     bool swipeGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerSwipeGesture();
         return true;
     }
     bool swipeGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerSwipeGesture();
         return true;
     }
 };
 
 class DragAndDropInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         if (!seat->isDragPointer()) {
             return false;
         }
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             if (Toplevel *t = input()->findToplevel(event->globalPos())) {
                 // TODO: consider decorations
                 if (t->surface() != seat->dragSurface()) {
                     if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
                         workspace()->raiseClient(c);
                     }
                     seat->setPointerPos(event->globalPos());
                     seat->setDragTarget(t->surface(), event->globalPos(), t->inputTransformation());
                 }
             } else {
                 // no window at that place, if we have a surface we need to reset
                 seat->setDragTarget(nullptr);
             }
             seat->setPointerPos(event->globalPos());
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             break;
         default:
             break;
         }
         // TODO: should we pass through effects?
         return true;
     }
 };
 
 KWIN_SINGLETON_FACTORY(InputRedirection)
 
 InputRedirection::InputRedirection(QObject *parent)
     : QObject(parent)
     , m_keyboard(new KeyboardInputRedirection(this))
     , m_pointer(new PointerInputRedirection(this))
     , m_touch(new TouchInputRedirection(this))
     , m_shortcuts(new GlobalShortcutsManager(this))
 {
     qRegisterMetaType<KWin::InputRedirection::KeyboardKeyState>();
     qRegisterMetaType<KWin::InputRedirection::PointerButtonState>();
     qRegisterMetaType<KWin::InputRedirection::PointerAxis>();
 #if HAVE_INPUT
     if (Application::usesLibinput()) {
         if (LogindIntegration::self()->hasSessionControl()) {
             setupLibInput();
         } else {
             if (LogindIntegration::self()->isConnected()) {
                 LogindIntegration::self()->takeControl();
             } else {
                 connect(LogindIntegration::self(), &LogindIntegration::connectedChanged, LogindIntegration::self(), &LogindIntegration::takeControl);
             }
             connect(LogindIntegration::self(), &LogindIntegration::hasSessionControlChanged, this,
                 [this] (bool sessionControl) {
                     if (sessionControl) {
                         setupLibInput();
                     }
                 }
             );
         }
         m_inputConfig = KSharedConfig::openConfig(QStringLiteral("kcminputrc"));
     }
 #endif
     connect(kwinApp(), &Application::workspaceCreated, this, &InputRedirection::setupWorkspace);
     reconfigure();
 }
 
 InputRedirection::~InputRedirection()
 {
     s_self = NULL;
     qDeleteAll(m_filters);
 }
 
 void InputRedirection::installInputEventFilter(InputEventFilter *filter)
 {
     m_filters << filter;
 }
 
 void InputRedirection::prepandInputEventFilter(InputEventFilter *filter)
 {
     m_filters.prepend(filter);
 }
 
 void InputRedirection::uninstallInputEventFilter(InputEventFilter *filter)
 {
     m_filters.removeAll(filter);
 }
 
 void InputRedirection::init()
 {
     m_shortcuts->init();
 }
 
 void InputRedirection::setupWorkspace()
 {
     if (waylandServer()) {
         using namespace KWayland::Server;
         FakeInputInterface *fakeInput = waylandServer()->display()->createFakeInput(this);
         fakeInput->create();
         connect(fakeInput, &FakeInputInterface::deviceCreated, this,
             [this] (FakeInputDevice *device) {
                 connect(device, &FakeInputDevice::authenticationRequested, this,
                     [this, device] (const QString &application, const QString &reason) {
                         Q_UNUSED(application)
                         Q_UNUSED(reason)
                         // TODO: make secure
                         device->setAuthentication(true);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerMotionRequested, this,
                     [this] (const QSizeF &delta) {
                         // TODO: Fix time
                         m_pointer->processMotion(globalPointer() + QPointF(delta.width(), delta.height()), 0);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonPressRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonPressed, 0);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonReleaseRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonReleased, 0);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerAxisRequested, this,
                     [this] (Qt::Orientation orientation, qreal delta) {
                         // TODO: Fix time
                         InputRedirection::PointerAxis axis;
                         switch (orientation) {
                         case Qt::Horizontal:
                             axis = InputRedirection::PointerAxisHorizontal;
                             break;
                         case Qt::Vertical:
                             axis = InputRedirection::PointerAxisVertical;
                             break;
                         default:
                             Q_UNREACHABLE();
                             break;
                         }
                         // TODO: Fix time
                         m_pointer->processAxis(axis, delta, 0);
                     }
                 );
                 connect(device, &FakeInputDevice::touchDownRequested, this,
                    [this] (quint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processDown(id, pos, 0);
                    }
                 );
                 connect(device, &FakeInputDevice::touchMotionRequested, this,
                    [this] (quint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processMotion(id, pos, 0);
                    }
                 );
                 connect(device, &FakeInputDevice::touchUpRequested, this,
                     [this] (quint32 id) {
                         // TODO: Fix time
                         m_touch->processUp(id, 0);
                     }
                 );
                 connect(device, &FakeInputDevice::touchCancelRequested, this,
                     [this] () {
                         m_touch->cancel();
                     }
                 );
                 connect(device, &FakeInputDevice::touchFrameRequested, this,
                    [this] () {
                        m_touch->frame();
                    }
                 );
             }
         );
         connect(workspace(), &Workspace::configChanged, this, &InputRedirection::reconfigure);
 
         m_keyboard->init();
         m_pointer->init();
         m_touch->init();
     }
     setupInputFilters();
 }
 
 void InputRedirection::setupInputFilters()
 {
 #if HAVE_INPUT
     if (LogindIntegration::self()->hasSessionControl()) {
         installInputEventFilter(new VirtualTerminalFilter);
     }
 #endif
     if (waylandServer()) {
         installInputEventFilter(new TerminateServerFilter);
         installInputEventFilter(new DragAndDropInputFilter);
         installInputEventFilter(new LockScreenFilter);
         m_windowSelector = new WindowSelectorFilter;
         installInputEventFilter(m_windowSelector);
     }
     installInputEventFilter(new ScreenEdgeInputFilter);
     installInputEventFilter(new EffectsFilter);
     installInputEventFilter(new MoveResizeFilter);
 #ifdef KWIN_BUILD_TABBOX
     installInputEventFilter(new TabBoxInputFilter);
 #endif
     installInputEventFilter(new GlobalShortcutFilter);
     installInputEventFilter(new InternalWindowEventFilter);
     installInputEventFilter(new DecorationEventFilter);
     if (waylandServer()) {
         installInputEventFilter(new WindowActionInputFilter);
         installInputEventFilter(new ForwardInputFilter);
     }
 }
 
 void InputRedirection::reconfigure()
 {
 #if HAVE_INPUT
     if (Application::usesLibinput()) {
         m_inputConfig->reparseConfiguration();
         const auto config = m_inputConfig->group(QStringLiteral("keyboard"));
         const int delay = config.readEntry("RepeatDelay", 660);
         const int rate = config.readEntry("RepeatRate", 25);
         const bool enabled = config.readEntry("KeyboardRepeating", 0) == 0;
 
         waylandServer()->seat()->setKeyRepeatInfo(enabled ? rate : 0, delay);
     }
 #endif
 }
 
 static KWayland::Server::SeatInterface *findSeat()
 {
     auto server = waylandServer();
     if (!server) {
         return nullptr;
     }
     return server->seat();
 }
 
 void InputRedirection::setupLibInput()
 {
 #if HAVE_INPUT
     if (!Application::usesLibinput()) {
         return;
     }
     if (m_libInput) {
         return;
     }
     LibInput::Connection *conn = LibInput::Connection::create(this);
     m_libInput = conn;
     if (conn) {
 
         if (waylandServer()) {
             // create relative pointer manager
             waylandServer()->display()->createRelativePointerManager(KWayland::Server::RelativePointerInterfaceVersion::UnstableV1, waylandServer()->display())->create();
         }
 
         conn->setInputConfig(m_inputConfig);
         conn->updateLEDs(m_keyboard->xkb()->leds());
         conn->setup();
         connect(m_keyboard, &KeyboardInputRedirection::ledsChanged, conn, &LibInput::Connection::updateLEDs);
         connect(conn, &LibInput::Connection::eventsRead, this,
             [this] {
                 m_libInput->processEvents();
             }, Qt::QueuedConnection
         );
         connect(conn, &LibInput::Connection::pointerButtonChanged, m_pointer, &PointerInputRedirection::processButton);
         connect(conn, &LibInput::Connection::pointerAxisChanged, m_pointer, &PointerInputRedirection::processAxis);
         connect(conn, &LibInput::Connection::pinchGestureBegin, m_pointer, &PointerInputRedirection::processPinchGestureBegin);
         connect(conn, &LibInput::Connection::pinchGestureUpdate, m_pointer, &PointerInputRedirection::processPinchGestureUpdate);
         connect(conn, &LibInput::Connection::pinchGestureEnd, m_pointer, &PointerInputRedirection::processPinchGestureEnd);
         connect(conn, &LibInput::Connection::pinchGestureCancelled, m_pointer, &PointerInputRedirection::processPinchGestureCancelled);
         connect(conn, &LibInput::Connection::swipeGestureBegin, m_pointer, &PointerInputRedirection::processSwipeGestureBegin);
         connect(conn, &LibInput::Connection::swipeGestureUpdate, m_pointer, &PointerInputRedirection::processSwipeGestureUpdate);
         connect(conn, &LibInput::Connection::swipeGestureEnd, m_pointer, &PointerInputRedirection::processSwipeGestureEnd);
         connect(conn, &LibInput::Connection::swipeGestureCancelled, m_pointer, &PointerInputRedirection::processSwipeGestureCancelled);
         connect(conn, &LibInput::Connection::keyChanged, m_keyboard, &KeyboardInputRedirection::processKey);
         connect(conn, &LibInput::Connection::pointerMotion, this,
             [this] (const QSizeF &delta, const QSizeF &deltaNonAccel, uint32_t time, quint64 timeMicroseconds, LibInput::Device *device) {
                 m_pointer->processMotion(m_pointer->pos() + QPointF(delta.width(), delta.height()), delta, deltaNonAccel, time, timeMicroseconds, device);
             }
         );
         connect(conn, &LibInput::Connection::pointerMotionAbsolute, this,
             [this] (QPointF orig, QPointF screen, uint32_t time, LibInput::Device *device) {
                 Q_UNUSED(orig)
                 m_pointer->processMotion(screen, time, device);
             }
         );
         connect(conn, &LibInput::Connection::touchDown, m_touch, &TouchInputRedirection::processDown);
         connect(conn, &LibInput::Connection::touchUp, m_touch, &TouchInputRedirection::processUp);
         connect(conn, &LibInput::Connection::touchMotion, m_touch, &TouchInputRedirection::processMotion);
         connect(conn, &LibInput::Connection::touchCanceled, m_touch, &TouchInputRedirection::cancel);
         connect(conn, &LibInput::Connection::touchFrame, m_touch, &TouchInputRedirection::frame);
         if (screens()) {
             setupLibInputWithScreens();
         } else {
             connect(kwinApp(), &Application::screensCreated, this, &InputRedirection::setupLibInputWithScreens);
         }
         if (auto s = findSeat()) {
             // Workaround for QTBUG-54371: if there is no real keyboard Qt doesn't request virtual keyboard
             s->setHasKeyboard(true);
             s->setHasPointer(conn->hasPointer());
             s->setHasTouch(conn->hasTouch());
             connect(conn, &LibInput::Connection::hasAlphaNumericKeyboardChanged, this,
                 [this] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     // TODO: this should update the seat, only workaround for QTBUG-54371
                     emit hasAlphaNumericKeyboardChanged(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasPointerChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasPointer(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasTouchChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasTouch(set);
                 }
             );
         }
         connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, m_libInput,
             [this] (bool active) {
                 if (!active) {
                     m_libInput->deactivate();
                 }
             }
         );
     }
 #endif
 }
 
 bool InputRedirection::hasAlphaNumericKeyboard()
 {
 #if HAVE_INPUT
     if (m_libInput) {
         return m_libInput->hasAlphaNumericKeyboard();
     }
 #endif
     return true;
 }
 
 void InputRedirection::setupLibInputWithScreens()
 {
 #if HAVE_INPUT
     if (!screens() || !m_libInput) {
         return;
     }
     m_libInput->setScreenSize(screens()->size());
     connect(screens(), &Screens::sizeChanged, this,
         [this] {
             m_libInput->setScreenSize(screens()->size());
         }
     );
 #endif
 }
 
 void InputRedirection::processPointerMotion(const QPointF &pos, uint32_t time)
 {
     m_pointer->processMotion(pos, time);
 }
 
 void InputRedirection::processPointerButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time)
 {
     m_pointer->processButton(button, state, time);
 }
 
 void InputRedirection::processPointerAxis(InputRedirection::PointerAxis axis, qreal delta, uint32_t time)
 {
     m_pointer->processAxis(axis, delta, time);
 }
 
 void InputRedirection::processKeyboardKey(uint32_t key, InputRedirection::KeyboardKeyState state, uint32_t time)
 {
     m_keyboard->processKey(key, state, time);
 }
 
 void InputRedirection::processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     m_keyboard->processModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void InputRedirection::processKeymapChange(int fd, uint32_t size)
 {
     m_keyboard->processKeymapChange(fd, size);
 }
 
 void InputRedirection::processTouchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processDown(id, pos, time);
 }
 
 void InputRedirection::processTouchUp(qint32 id, quint32 time)
 {
     m_touch->processUp(id, time);
 }
 
 void InputRedirection::processTouchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processMotion(id, pos, time);
 }
 
 void InputRedirection::cancelTouch()
 {
     m_touch->cancel();
 }
 
 void InputRedirection::touchFrame()
 {
     m_touch->frame();
 }
 
 Qt::MouseButtons InputRedirection::qtButtonStates() const
 {
     return m_pointer->buttons();
 }
 
 static bool acceptsInput(Toplevel *t, const QPoint &pos)
 {
     const QRegion input = t->inputShape();
     if (input.isEmpty()) {
         return true;
     }
     return input.translated(t->pos()).contains(pos);
 }
 
 Toplevel *InputRedirection::findToplevel(const QPoint &pos)
 {
     if (!Workspace::self()) {
         return nullptr;
     }
     const bool isScreenLocked = waylandServer() && waylandServer()->isScreenLocked();
     // TODO: check whether the unmanaged wants input events at all
     if (!isScreenLocked) {
         // if an effect overrides the cursor we don't have a window to focus
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
             return nullptr;
         }
         const UnmanagedList &unmanaged = Workspace::self()->unmanagedList();
         foreach (Unmanaged *u, unmanaged) {
             if (u->geometry().contains(pos) && acceptsInput(u, pos)) {
                 return u;
             }
         }
     }
     const ToplevelList &stacking = Workspace::self()->stackingOrder();
     if (stacking.isEmpty()) {
         return NULL;
     }
     auto it = stacking.end();
     do {
         --it;
         Toplevel *t = (*it);
         if (t->isDeleted()) {
             // a deleted window doesn't get mouse events
             continue;
         }
         if (AbstractClient *c = dynamic_cast<AbstractClient*>(t)) {
             if (!c->isOnCurrentActivity() || !c->isOnCurrentDesktop() || c->isMinimized() || !c->isCurrentTab() || c->isHiddenInternal()) {
                 continue;
             }
         }
         if (!t->readyForPainting()) {
             continue;
         }
         if (isScreenLocked) {
             if (!t->isLockScreen() && !t->isInputMethod()) {
                 continue;
             }
         }
         if (t->inputGeometry().contains(pos) && acceptsInput(t, pos)) {
             return t;
         }
     } while (it != stacking.begin());
     return NULL;
 }
 
 Qt::KeyboardModifiers InputRedirection::keyboardModifiers() const
 {
     return m_keyboard->modifiers();
 }
 
 void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action)
 {
     m_shortcuts->registerShortcut(action, shortcut);
     registerShortcutForGlobalAccelTimestamp(action);
 }
 
 void InputRedirection::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     m_shortcuts->registerPointerShortcut(action, modifiers, pointerButtons);
 }
 
 void InputRedirection::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     m_shortcuts->registerAxisShortcut(action, modifiers, axis);
 }
 
 void InputRedirection::registerGlobalAccel(KGlobalAccelInterface *interface)
 {
     m_shortcuts->setKGlobalAccelInterface(interface);
 }
 
 void InputRedirection::registerShortcutForGlobalAccelTimestamp(QAction *action)
 {
     connect(action, &QAction::triggered, kwinApp(), [action] {
         QVariant timestamp = action->property("org.kde.kglobalaccel.activationTimestamp");
         bool ok = false;
         const quint32 t = timestamp.toULongLong(&ok);
         if (ok) {
             kwinApp()->setX11Time(t);
         }
     });
 }
 
 void InputRedirection::warpPointer(const QPointF &pos)
 {
     m_pointer->warp(pos);
 }
 
 bool InputRedirection::supportsPointerWarping() const
 {
     return m_pointer->supportsWarping();
 }
 
 QPointF InputRedirection::globalPointer() const
 {
     return m_pointer->pos();
 }
 
 void InputRedirection::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!m_windowSelector || m_windowSelector->isActive()) {
         callback(nullptr);
         return;
     }
     m_windowSelector->start(callback);
     m_pointer->setWindowSelectionCursor(cursorName);
 }
 
+void InputRedirection::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
+{
+    if (!m_windowSelector || m_windowSelector->isActive()) {
+        callback(QPoint(-1, -1));
+        return;
+    }
+    m_windowSelector->start(callback);
+    m_pointer->setWindowSelectionCursor(QByteArray());
+}
+
 bool InputRedirection::isSelectingWindow() const
 {
     return m_windowSelector ? m_windowSelector->isActive() : false;
 }
 
 InputDeviceHandler::InputDeviceHandler(InputRedirection *input)
     : QObject(input)
     , m_input(input)
 {
 }
 
 InputDeviceHandler::~InputDeviceHandler() = default;
 
 void InputDeviceHandler::updateDecoration(Toplevel *t, const QPointF &pos)
 {
     const auto oldDeco = m_decoration;
     bool needsReset = waylandServer()->isScreenLocked();
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(t)) {
         // check whether it's on a Decoration
         if (c->decoratedClient()) {
             const QRect clientRect = QRect(c->clientPos(), c->clientSize()).translated(c->pos());
             if (!clientRect.contains(pos.toPoint())) {
                 m_decoration = c->decoratedClient();
             } else {
                 needsReset = true;
             }
         } else {
             needsReset = true;
         }
     } else {
         needsReset = true;
     }
     if (needsReset) {
         m_decoration.clear();
     }
 
     bool leftSend = false;
     auto oldWindow = qobject_cast<AbstractClient*>(m_window.data());
     if (oldWindow && (m_decoration && m_decoration->client() != oldWindow)) {
         leftSend = true;
         oldWindow->leaveEvent();
     }
 
     if (oldDeco && oldDeco != m_decoration) {
         if (oldDeco->client() != t && !leftSend) {
             leftSend = true;
             oldDeco->client()->leaveEvent();
         }
         // send leave
         QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::instance()->sendEvent(oldDeco->decoration(), &event);
     }
     if (m_decoration) {
         if (m_decoration->client() != oldWindow) {
             m_decoration->client()->enterEvent(pos.toPoint());
             workspace()->updateFocusMousePosition(pos.toPoint());
         }
         const QPointF p = pos - t->pos();
         QHoverEvent event(QEvent::HoverMove, p, p);
         QCoreApplication::instance()->sendEvent(m_decoration->decoration(), &event);
         m_decoration->client()->processDecorationMove(p.toPoint(), pos.toPoint());
     }
 }
 
 void InputDeviceHandler::updateInternalWindow(const QPointF &pos)
 {
     const auto oldInternalWindow = m_internalWindow;
     bool found = false;
     // TODO: screen locked check without going through wayland server
     bool needsReset = waylandServer()->isScreenLocked();
     const auto &internalClients = waylandServer()->internalClients();
     const bool change = m_internalWindow.isNull() || !(m_internalWindow->flags().testFlag(Qt::Popup) && m_internalWindow->isVisible());
     if (!internalClients.isEmpty() && change) {
         auto it = internalClients.end();
         do {
             it--;
             if (QWindow *w = (*it)->internalWindow()) {
                 if (!w->isVisible()) {
                     continue;
                 }
                 if ((*it)->geometry().contains(pos.toPoint())) {
                     // check input mask
                     const QRegion mask = w->mask().translated(w->geometry().topLeft());
                     if (!mask.isEmpty() && !mask.contains(pos.toPoint())) {
                         continue;
                     }
                     m_internalWindow = QPointer<QWindow>(w);
                     found = true;
                     break;
                 }
             }
         } while (it != internalClients.begin());
         if (!found) {
             needsReset = true;
         }
     }
     if (needsReset) {
         m_internalWindow.clear();
     }
     if (oldInternalWindow != m_internalWindow) {
         // changed
         if (oldInternalWindow) {
             QEvent event(QEvent::Leave);
             QCoreApplication::sendEvent(oldInternalWindow.data(), &event);
         }
         if (m_internalWindow) {
             QEnterEvent event(pos - m_internalWindow->position(),
                               pos - m_internalWindow->position(),
                               pos);
             QCoreApplication::sendEvent(m_internalWindow.data(), &event);
         }
         emit internalWindowChanged();
     }
 }
 
 } // namespace
diff --git a/input.h b/input.h
index a3579fca7..5a33551a9 100644
--- a/input.h
+++ b/input.h
@@ -1,369 +1,370 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_INPUT_H
 #define KWIN_INPUT_H
 #include <kwinglobals.h>
 #include <QAction>
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <config-kwin.h>
 
 #include <KSharedConfig>
 
 #include <functional>
 
 class KGlobalAccelInterface;
 class QKeySequence;
 class QMouseEvent;
 class QKeyEvent;
 class QWheelEvent;
 
 namespace KWin
 {
 class GlobalShortcutsManager;
 class Toplevel;
 class InputEventFilter;
 class KeyboardInputRedirection;
 class PointerInputRedirection;
 class TouchInputRedirection;
 class WindowSelectorFilter;
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 }
 
 namespace LibInput
 {
     class Connection;
 }
 
 /**
  * @brief This class is responsible for redirecting incoming input to the surface which currently
  * has input or send enter/leave events.
  *
  * In addition input is intercepted before passed to the surfaces to have KWin internal areas
  * getting input first (e.g. screen edges) and filter the input event out if we currently have
  * a full input grab.
  *
  */
 class KWIN_EXPORT InputRedirection : public QObject
 {
     Q_OBJECT
 public:
     enum PointerButtonState {
         PointerButtonReleased,
         PointerButtonPressed
     };
     enum PointerAxis {
         PointerAxisVertical,
         PointerAxisHorizontal
     };
     enum KeyboardKeyState {
         KeyboardKeyReleased,
         KeyboardKeyPressed,
         KeyboardKeyAutoRepeat
     };
     virtual ~InputRedirection();
     void init();
 
     /**
      * @return const QPointF& The current global pointer position
      */
     QPointF globalPointer() const;
     Qt::MouseButtons qtButtonStates() const;
     Qt::KeyboardModifiers keyboardModifiers() const;
 
     void registerShortcut(const QKeySequence &shortcut, QAction *action);
     /**
      * @overload
      *
      * Like registerShortcut, but also connects QAction::triggered to the @p slot on @p receiver.
      * It's recommended to use this method as it ensures that the X11 timestamp is updated prior
      * to the @p slot being invoked. If not using this overload it's required to ensure that
      * registerShortcut is called before connecting to QAction's triggered signal.
      **/
     template <typename T>
     void registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, void (T::*slot)());
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action);
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action);
     void registerGlobalAccel(KGlobalAccelInterface *interface);
 
     /**
      * @internal
      */
     void processPointerMotion(const QPointF &pos, uint32_t time);
     /**
      * @internal
      */
     void processPointerButton(uint32_t button, PointerButtonState state, uint32_t time);
     /**
      * @internal
      */
     void processPointerAxis(PointerAxis axis, qreal delta, uint32_t time);
     /**
      * @internal
      */
     void processKeyboardKey(uint32_t key, KeyboardKeyState state, uint32_t time);
     /**
      * @internal
      */
     void processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     /**
      * @internal
      **/
     void processKeymapChange(int fd, uint32_t size);
     void processTouchDown(qint32 id, const QPointF &pos, quint32 time);
     void processTouchUp(qint32 id, quint32 time);
     void processTouchMotion(qint32 id, const QPointF &pos, quint32 time);
     void cancelTouch();
     void touchFrame();
 
     bool supportsPointerWarping() const;
     void warpPointer(const QPointF &pos);
 
     /**
      * Adds the @p filter to the list of event filters and makes it the first
      * event filter in processing.
      *
      * Note: the event filter will get events before the lock screen can get them, thus
      * this is a security relevant method.
      **/
     void prepandInputEventFilter(InputEventFilter *filter);
     void uninstallInputEventFilter(InputEventFilter *filter);
     Toplevel *findToplevel(const QPoint &pos);
     GlobalShortcutsManager *shortcuts() const {
         return m_shortcuts;
     }
 
     QVector<InputEventFilter*> filters() const {
         return m_filters;
     }
     KeyboardInputRedirection *keyboard() const {
         return m_keyboard;
     }
     PointerInputRedirection *pointer() const {
         return m_pointer;
     }
     TouchInputRedirection *touch() const {
         return m_touch;
     }
 
     bool hasAlphaNumericKeyboard();
 
     void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName);
+    void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
     bool isSelectingWindow() const;
 
 Q_SIGNALS:
     /**
      * @brief Emitted when the global pointer position changed
      *
      * @param pos The new global pointer position.
      */
     void globalPointerChanged(const QPointF &pos);
     /**
      * @brief Emitted when the state of a pointer button changed.
      *
      * @param button The button which changed
      * @param state The new button state
      */
     void pointerButtonStateChanged(uint32_t button, InputRedirection::PointerButtonState state);
     /**
      * @brief Emitted when a pointer axis changed
      *
      * @param axis The axis on which the even occurred
      * @param delta The delta of the event.
      */
     void pointerAxisChanged(InputRedirection::PointerAxis axis, qreal delta);
     /**
      * @brief Emitted when the modifiers changes.
      *
      * Only emitted for the mask which is provided by Qt::KeyboardModifiers, if other modifiers
      * change signal is not emitted
      *
      * @param newMods The new modifiers state
      * @param oldMods The previous modifiers state
      */
     void keyboardModifiersChanged(Qt::KeyboardModifiers newMods, Qt::KeyboardModifiers oldMods);
     /**
      * @brief Emitted when the state of a key changed.
      *
      * @param keyCode The keycode of the key which changed
      * @param oldMods The new key state
      */
     void keyStateChanged(quint32 keyCode, InputRedirection::KeyboardKeyState state);
 
     void hasAlphaNumericKeyboardChanged(bool set);
 
 private:
     void setupLibInput();
     void setupLibInputWithScreens();
     void registerShortcutForGlobalAccelTimestamp(QAction *action);
     void setupWorkspace();
     void reconfigure();
     void setupInputFilters();
     void installInputEventFilter(InputEventFilter *filter);
     KeyboardInputRedirection *m_keyboard;
     PointerInputRedirection *m_pointer;
     TouchInputRedirection *m_touch;
 
     GlobalShortcutsManager *m_shortcuts;
 
     LibInput::Connection *m_libInput = nullptr;
 
     WindowSelectorFilter *m_windowSelector = nullptr;
 
     QVector<InputEventFilter*> m_filters;
     KSharedConfigPtr m_inputConfig;
 
     KWIN_SINGLETON(InputRedirection)
     friend InputRedirection *input();
     friend class DecorationEventFilter;
     friend class InternalWindowEventFilter;
     friend class ForwardInputFilter;
 };
 
 /**
  * Base class for filtering input events inside InputRedirection.
  *
  * The idea behind the InputEventFilter is to have task oriented
  * filters. E.g. there is one filter taking care of a locked screen,
  * one to take care of interacting with window decorations, etc.
  *
  * A concrete subclass can reimplement the virtual methods and decide
  * whether an event should be filtered out or not by returning either
  * @c true or @c false. E.g. the lock screen filter can easily ensure
  * that all events are filtered out.
  *
  * As soon as a filter returns @c true the processing is stopped. If
  * a filter returns @c false the next one is invoked. This means a filter
  * installed early gets to see more events than a filter installed later on.
  *
  * Deleting an instance of InputEventFilter automatically uninstalls it from
  * InputRedirection.
  **/
 class KWIN_EXPORT InputEventFilter
 {
 public:
     InputEventFilter();
     virtual ~InputEventFilter();
 
     /**
      * Event filter for pointer events which can be described by a QMouseEvent.
      *
      * Please note that the button translation in QMouseEvent cannot cover all
      * possible buttons. Because of that also the @p nativeButton code is passed
      * through the filter. For internal areas it's fine to use @p event, but for
      * passing to client windows the @p nativeButton should be used.
      *
      * @param event The event information about the move or button press/release
      * @param nativeButton The native key code of the button, for move events 0
      * @return @c true to stop further event processing, @c false to pass to next filter
      **/
     virtual bool pointerEvent(QMouseEvent *event, quint32 nativeButton);
     /**
      * Event filter for pointer axis events.
      *
      * @param event The event information about the axis event
      * @return @c true to stop further event processing, @c false to pass to next filter
      **/
     virtual bool wheelEvent(QWheelEvent *event);
     /**
      * Event filter for keyboard events.
      *
      * @param event The event information about the key event
      * @return @c tru to stop further event processing, @c false to pass to next filter.
      **/
     virtual bool keyEvent(QKeyEvent *event);
     virtual bool touchDown(quint32 id, const QPointF &pos, quint32 time);
     virtual bool touchMotion(quint32 id, const QPointF &pos, quint32 time);
     virtual bool touchUp(quint32 id, quint32 time);
 
     virtual bool pinchGestureBegin(int fingerCount, quint32 time);
     virtual bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     virtual bool pinchGestureEnd(quint32 time);
     virtual bool pinchGestureCancelled(quint32 time);
 
     virtual bool swipeGestureBegin(int fingerCount, quint32 time);
     virtual bool swipeGestureUpdate(const QSizeF &delta, quint32 time);
     virtual bool swipeGestureEnd(quint32 time);
     virtual bool swipeGestureCancelled(quint32 time);
 
 protected:
     void passToWaylandServer(QKeyEvent *event);
 };
 
 class InputDeviceHandler : public QObject
 {
     Q_OBJECT
 public:
     virtual ~InputDeviceHandler();
 
     QPointer<Toplevel> window() const {
         return m_window;
     }
     QPointer<Decoration::DecoratedClientImpl> decoration() const {
         return m_decoration;
     }
     QPointer<QWindow> internalWindow() const {
         return m_internalWindow;
     }
 
 Q_SIGNALS:
     void decorationChanged();
     void internalWindowChanged();
 
 protected:
     explicit InputDeviceHandler(InputRedirection *parent);
     void updateDecoration(Toplevel *t, const QPointF &pos);
     void updateInternalWindow(const QPointF &pos);
     InputRedirection *m_input;
     /**
      * @brief The Toplevel which currently receives events
      */
     QPointer<Toplevel> m_window;
     /**
      * @brief The Decoration which currently receives events.
      **/
     QPointer<Decoration::DecoratedClientImpl> m_decoration;
     QPointer<QWindow> m_internalWindow;
 };
 
 inline
 InputRedirection *input()
 {
     return InputRedirection::s_self;
 }
 
 template <typename T>
 inline
 void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, void (T::*slot)()) {
     registerShortcut(shortcut, action);
     connect(action, &QAction::triggered, receiver, slot);
 }
 
 } // namespace KWin
 
 Q_DECLARE_METATYPE(KWin::InputRedirection::KeyboardKeyState)
 Q_DECLARE_METATYPE(KWin::InputRedirection::PointerButtonState)
 Q_DECLARE_METATYPE(KWin::InputRedirection::PointerAxis)
 
 #endif // KWIN_INPUT_H
diff --git a/libkwineffects/kwineffects.h b/libkwineffects/kwineffects.h
index ceb4daab7..63e63dc66 100644
--- a/libkwineffects/kwineffects.h
+++ b/libkwineffects/kwineffects.h
@@ -1,3349 +1,3364 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWINEFFECTS_H
 #define KWINEFFECTS_H
 
 #include <kwinconfig.h>
 #include <kwineffects_export.h>
 #include <kwinglobals.h>
 
 #include <QIcon>
 #include <QPair>
 #include <QSet>
 #include <QRect>
 #include <QtGui/QRegion>
 #include <QtGui/QVector2D>
 #include <QtGui/QVector3D>
 
 #include <QVector>
 #include <QLoggingCategory>
 #include <QList>
 #include <QHash>
 #include <QStack>
 #include <QScopedPointer>
 
 #include <KPluginFactory>
 
 #include <assert.h>
 #include <limits.h>
 #include <netwm.h>
 
 #include <functional>
 
 class KConfigGroup;
 class QFont;
 class QGraphicsScale;
 class QKeyEvent;
 class QMatrix4x4;
 
 /**
  * Logging category to be used inside the KWin effects.
  * Do not use in this library.
  **/
 Q_DECLARE_LOGGING_CATEGORY(KWINEFFECTS)
 
 namespace KWayland {
     namespace Server {
         class SurfaceInterface;
         class Display;
     }
 }
 
 namespace KWin
 {
 
 class PaintDataPrivate;
 class WindowPaintDataPrivate;
 
 class EffectWindow;
 class EffectWindowGroup;
 class EffectFrame;
 class EffectFramePrivate;
 class Effect;
 class WindowQuad;
 class GLShader;
 class XRenderPicture;
 class WindowQuadList;
 class WindowPrePaintData;
 class WindowPaintData;
 class ScreenPrePaintData;
 class ScreenPaintData;
 
 typedef QPair< QString, Effect* > EffectPair;
 typedef QList< KWin::EffectWindow* > EffectWindowList;
 
 
 /** @defgroup kwineffects KWin effects library
  * KWin effects library contains necessary classes for creating new KWin
  * compositing effects.
  *
  * @section creating Creating new effects
  * This example will demonstrate the basics of creating an effect. We'll use
  *  CoolEffect as the class name, cooleffect as internal name and
  *  "Cool Effect" as user-visible name of the effect.
  *
  * This example doesn't demonstrate how to write the effect's code. For that,
  *  see the documentation of the Effect class.
  *
  * @subsection creating-class CoolEffect class
  * First you need to create CoolEffect class which has to be a subclass of
  *  @ref KWin::Effect. In that class you can reimplement various virtual
  *  methods to control how and where the windows are drawn.
  *
  * @subsection creating-macro KWIN_EFFECT_FACTORY macro
  * This library provides a specialized KPluginFactory subclass and macros to
  * create a sub class. This subclass of KPluginFactory has to be used, otherwise
  * KWin won't load the plugin. Use the @ref KWIN_EFFECT_FACTORY macro to create the
  * plugin factory.
  *
  * @subsection creating-buildsystem Buildsystem
  * To build the effect, you can use the KWIN_ADD_EFFECT() cmake macro which
  *  can be found in effects/CMakeLists.txt file in KWin's source. First
  *  argument of the macro is the name of the library that will contain
  *  your effect. Although not strictly required, it is usually a good idea to
  *  use the same name as your effect's internal name there. Following arguments
  *  to the macro are the files containing your effect's source. If our effect's
  *  source is in cooleffect.cpp, we'd use following:
  * @code
  *  KWIN_ADD_EFFECT(cooleffect cooleffect.cpp)
  * @endcode
  *
  * This macro takes care of compiling your effect. You'll also need to install
  *  your effect's .desktop file, so the example CMakeLists.txt file would be
  *  as follows:
  * @code
  *  KWIN_ADD_EFFECT(cooleffect cooleffect.cpp)
  *  install( FILES cooleffect.desktop DESTINATION ${SERVICES_INSTALL_DIR}/kwin )
  * @endcode
  *
  * @subsection creating-desktop Effect's .desktop file
  * You will also need to create .desktop file to set name, description, icon
  *  and other properties of your effect. Important fields of the .desktop file
  *  are:
  *  @li Name User-visible name of your effect
  *  @li Icon Name of the icon of the effect
  *  @li Comment Short description of the effect
  *  @li Type must be "Service"
  *  @li X-KDE-ServiceTypes must be "KWin/Effect"
  *  @li X-KDE-PluginInfo-Name effect's internal name as passed to the KWIN_EFFECT macro plus "kwin4_effect_" prefix
  *  @li X-KDE-PluginInfo-Category effect's category. Should be one of Appearance, Accessibility, Window Management, Demos, Tests, Misc
  *  @li X-KDE-PluginInfo-EnabledByDefault whether the effect should be enabled by default (use sparingly). Default is false
  *  @li X-KDE-Library name of the library containing the effect. This is the first argument passed to the KWIN_ADD_EFFECT macro in cmake file plus "kwin4_effect_" prefix.
  *
  * Example cooleffect.desktop file follows:
  * @code
 [Desktop Entry]
 Name=Cool Effect
 Comment=The coolest effect you've ever seen
 Icon=preferences-system-windows-effect-cooleffect
 
 Type=Service
 X-KDE-ServiceTypes=KWin/Effect
 X-KDE-PluginInfo-Author=My Name
 X-KDE-PluginInfo-Email=my@email.here
 X-KDE-PluginInfo-Name=kwin4_effect_cooleffect
 X-KDE-PluginInfo-Category=Misc
 X-KDE-Library=kwin4_effect_cooleffect
  * @endcode
  *
  *
  * @section accessing Accessing windows and workspace
  * Effects can gain access to the properties of windows and workspace via
  *  EffectWindow and EffectsHandler classes.
  *
  * There is one global EffectsHandler object which you can access using the
  *  @ref effects pointer.
  * For each window, there is an EffectWindow object which can be used to read
  *  window properties such as position and also to change them.
  *
  * For more information about this, see the documentation of the corresponding
  *  classes.
  *
  * @{
  **/
 
 #define KWIN_EFFECT_API_MAKE_VERSION( major, minor ) (( major ) << 8 | ( minor ))
 #define KWIN_EFFECT_API_VERSION_MAJOR 0
 #define KWIN_EFFECT_API_VERSION_MINOR 224
 #define KWIN_EFFECT_API_VERSION KWIN_EFFECT_API_MAKE_VERSION( \
         KWIN_EFFECT_API_VERSION_MAJOR, KWIN_EFFECT_API_VERSION_MINOR )
 
 enum WindowQuadType {
     WindowQuadError, // for the stupid default ctor
     WindowQuadContents,
     WindowQuadDecoration,
     // Shadow Quad types
     WindowQuadShadow,             // OpenGL only. The other shadow types are only used by Xrender
     WindowQuadShadowTop,
     WindowQuadShadowTopRight,
     WindowQuadShadowRight,
     WindowQuadShadowBottomRight,
     WindowQuadShadowBottom,
     WindowQuadShadowBottomLeft,
     WindowQuadShadowLeft,
     WindowQuadShadowTopLeft,
     EFFECT_QUAD_TYPE_START = 100 ///< @internal
 };
 
 /**
  * EffectWindow::setData() and EffectWindow::data() global roles.
  * All values between 0 and 999 are reserved for global roles.
  */
 enum DataRole {
     // Grab roles are used to force all other animations to ignore the window.
     // The value of the data is set to the Effect's `this` value.
     WindowAddedGrabRole = 1,
     WindowClosedGrabRole,
     WindowMinimizedGrabRole,
     WindowUnminimizedGrabRole,
     WindowForceBlurRole, ///< For fullscreen effects to enforce blurring of windows,
     WindowBlurBehindRole, ///< For single windows to blur behind
     WindowForceBackgroundContrastRole, ///< For fullscreen effects to enforce the background contrast,
     WindowBackgroundContrastRole, ///< For single windows to enable Background contrast
     LanczosCacheRole
 };
 
 /**
  * Style types used by @ref EffectFrame.
  * @since 4.6
  */
 enum EffectFrameStyle {
     EffectFrameNone, ///< Displays no frame around the contents.
     EffectFrameUnstyled, ///< Displays a basic box around the contents.
     EffectFrameStyled ///< Displays a Plasma-styled frame around the contents.
 };
 
 /**
  * Infinite region (i.e. a special region type saying that everything needs to be painted).
  */
 KWINEFFECTS_EXPORT inline
 QRect infiniteRegion()
 {
     // INT_MIN / 2 because width/height is used (INT_MIN+INT_MAX==-1)
     return QRect(INT_MIN / 2, INT_MIN / 2, INT_MAX, INT_MAX);
 }
 
 /**
  * @short Base class for all KWin effects
  *
  * This is the base class for all effects. By reimplementing virtual methods
  *  of this class, you can customize how the windows are painted.
  *
  * The virtual methods are used for painting and need to be implemented for
  * custom painting.
  *
  * In order to react to state changes (e.g. a window gets closed) the effect
  * should provide slots for the signals emitted by the EffectsHandler.
  *
  * @section Chaining
  * Most methods of this class are called in chain style. This means that when
  *  effects A and B area active then first e.g. A::paintWindow() is called and
  *  then from within that method B::paintWindow() is called (although
  *  indirectly). To achieve this, you need to make sure to call corresponding
  *  method in EffectsHandler class from each such method (using @ref effects
  *  pointer):
  * @code
  *  void MyEffect::postPaintScreen()
  *  {
  *      // Do your own processing here
  *      ...
  *      // Call corresponding EffectsHandler method
  *      effects->postPaintScreen();
  *  }
  * @endcode
  *
  * @section Effectsptr Effects pointer
  * @ref effects pointer points to the global EffectsHandler object that you can
  *  use to interact with the windows.
  *
  * @section painting Painting stages
  * Painting of windows is done in three stages:
  * @li First, the prepaint pass.<br>
  *  Here you can specify how the windows will be painted, e.g. that they will
  *  be translucent and transformed.
  * @li Second, the paint pass.<br>
  *  Here the actual painting takes place. You can change attributes such as
  *  opacity of windows as well as apply transformations to them. You can also
  *  paint something onto the screen yourself.
  * @li Finally, the postpaint pass.<br>
  *  Here you can mark windows, part of windows or even the entire screen for
  *  repainting to create animations.
  *
  * For each stage there are *Screen() and *Window() methods. The window method
  *  is called for every window which the screen method is usually called just
  *  once.
  *
  * @section OpenGL
  * Effects can use OpenGL if EffectsHandler::isOpenGLCompositing() returns @c true.
  * The OpenGL context may not always be current when code inside the effect is
  * executed. The framework ensures that the OpenGL context is current when the Effect
  * gets created, destroyed or reconfigured and during the painting stages. All virtual
  * methods which have the OpenGL context current are documented.
  *
  * If OpenGL code is going to be executed outside the painting stages, e.g. in reaction
  * to a global shortcut, it is the task of the Effect to make the OpenGL context current:
  * @code
  * effects->makeOpenGLContextCurrent();
  * @endcode
  *
  * There is in general no need to call the matching doneCurrent method.
  **/
 class KWINEFFECTS_EXPORT Effect : public QObject
 {
     Q_OBJECT
 public:
     /** Flags controlling how painting is done. */
     // TODO: is that ok here?
     enum {
         /**
          * Window (or at least part of it) will be painted opaque.
          **/
         PAINT_WINDOW_OPAQUE         = 1 << 0,
         /**
          * Window (or at least part of it) will be painted translucent.
          **/
         PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
         /**
          * Window will be painted with transformed geometry.
          **/
         PAINT_WINDOW_TRANSFORMED    = 1 << 2,
         /**
          * Paint only a region of the screen (can be optimized, cannot
          * be used together with TRANSFORMED flags).
          **/
         PAINT_SCREEN_REGION         = 1 << 3,
         /**
          * The whole screen will be painted with transformed geometry.
          * Forces the entire screen to be painted.
          **/
         PAINT_SCREEN_TRANSFORMED    = 1 << 4,
         /**
          * At least one window will be painted with transformed geometry.
          * Forces the entire screen to be painted.
          **/
         PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
         /**
          * Clear whole background as the very first step, without optimizing it
          **/
         PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
         // PAINT_DECORATION_ONLY = 1 << 7 has been deprecated
         /**
          * Window will be painted with a lanczos filter.
          **/
         PAINT_WINDOW_LANCZOS = 1 << 8
         // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS = 1 << 9 has been removed
     };
 
     enum Feature {
         Nothing = 0, Resize, GeometryTip, Outline, ScreenInversion, Blur, Contrast, HighlightWindows
     };
 
     /**
      * Constructs new Effect object.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is constructed.
      **/
     Effect();
     /**
      * Destructs the Effect object.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is destroyed.
      **/
     virtual ~Effect();
 
     /**
      * Flags describing which parts of configuration have changed.
      */
     enum ReconfigureFlag {
         ReconfigureAll = 1 << 0 /// Everything needs to be reconfigured.
     };
     Q_DECLARE_FLAGS(ReconfigureFlags, ReconfigureFlag)
 
     /**
      * Called when configuration changes (either the effect's or KWin's global).
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is reconfigured. If this method is called from within the Effect it is
      * required to ensure that the context is current if the implementation does OpenGL calls.
      */
     virtual void reconfigure(ReconfigureFlags flags);
 
     /**
      * Called when another effect requests the proxy for this effect.
      */
     virtual void* proxy();
 
     /**
      * Called before starting to paint the screen.
      * In this method you can:
      * @li set whether the windows or the entire screen will be transformed
      * @li change the region of the screen that will be painted
      * @li do various housekeeping tasks such as initing your effect's variables
             for the upcoming paint pass or updating animation's progress
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
     **/
     virtual void prePaintScreen(ScreenPrePaintData& data, int time);
     /**
      * In this method you can:
      * @li paint something on top of the windows (by painting after calling
      *      effects->paintScreen())
      * @li paint multiple desktops and/or multiple copies of the same desktop
      *      by calling effects->paintScreen() multiple times
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void paintScreen(int mask, QRegion region, ScreenPaintData& data);
     /**
      * Called after all the painting has been finished.
      * In this method you can:
      * @li schedule next repaint in case of animations
      * You shouldn't paint anything here.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void postPaintScreen();
 
     /**
      * Called for every window before the actual paint pass
      * In this method you can:
      * @li enable or disable painting of the window (e.g. enable paiting of minimized window)
      * @li set window to be painted with translucency
      * @li set window to be transformed
      * @li request the window to be divided into multiple parts
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time);
     /**
      * This is the main method for painting windows.
      * In this method you can:
      * @li do various transformations
      * @li change opacity of the window
      * @li change brightness and/or saturation, if it's supported
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data);
     /**
      * Called for every window after all painting has been finished.
      * In this method you can:
      * @li schedule next repaint for individual window(s) in case of animations
      * You shouldn't paint anything here.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void postPaintWindow(EffectWindow* w);
 
     /**
      * This method is called directly before painting an @ref EffectFrame.
      * You can implement this method if you need to bind a shader or perform
      * other operations before the frame is rendered.
      * @param frame The EffectFrame which will be rendered
      * @param region Region to restrict painting to
      * @param opacity Opacity of text/icon
      * @param frameOpacity Opacity of background
      * @since 4.6
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity);
 
     /**
      * Called on Transparent resizes.
      * return true if your effect substitutes questioned feature
     */
     virtual bool provides(Feature);
 
     /**
      * Performs the @p feature with the @p arguments.
      *
      * This allows to have specific protocols between KWin core and an Effect.
      *
      * The method is supposed to return @c true if it performed the features,
      * @c false otherwise.
      *
      * The default implementation returns @c false.
      * @since 5.8
      **/
     virtual bool perform(Feature feature, const QVariantList &arguments);
 
     /**
      * Can be called to draw multiple copies (e.g. thumbnails) of a window.
      * You can change window's opacity/brightness/etc here, but you can't
      *  do any transformations.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      **/
     virtual void drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data);
 
     /**
      * Define new window quads so that they can be transformed by other effects.
      * It's up to the effect to keep track of them.
      **/
     virtual void buildQuads(EffectWindow* w, WindowQuadList& quadList);
 
     virtual void windowInputMouseEvent(QEvent* e);
     virtual void grabbedKeyboardEvent(QKeyEvent* e);
 
     /**
      * Overwrite this method to indicate whether your effect will be doing something in
      * the next frame to be rendered. If the method returns @c false the effect will be
      * excluded from the chained methods in the next rendered frame.
      *
      * This method is called always directly before the paint loop begins. So it is totally
      * fine to e.g. react on a window event, issue a repaint to trigger an animation and
      * change a flag to indicate that this method returns @c true.
      *
      * As the method is called each frame, you should not perform complex calculations.
      * Best use just a boolean flag.
      *
      * The default implementation of this method returns @c true.
      * @since 4.8
      **/
     virtual bool isActive() const;
 
     /**
      * Reimplement this method to provide online debugging.
      * This could be as trivial as printing specific detail informations about the effect state
      * but could also be used to move the effect in and out of a special debug modes, clear bogus
      * data, etc.
      * Notice that the functions is const by intent! Whenever you alter the state of the object
      * due to random user input, you should do so with greatest care, hence const_cast<> your
      * object - signalling "let me alone, i know what i'm doing"
      * @param parameter A freeform string user input for your effect to interpret.
      * @since 4.11
      */
     virtual QString debug(const QString &parameter) const;
 
     /**
      * Reimplement this method to indicate where in the Effect chain the Effect should be placed.
      *
      * A low number indicates early chain position, thus before other Effects got called, a high
      * number indicates a late position. The returned number should be in the interval [0, 100].
      * The default value is 0.
      *
      * In KWin4 this information was provided in the Effect's desktop file as property
      * X-KDE-Ordering. In the case of Scripted Effects this property is still used.
      *
      * @since 5.0
      **/
     virtual int requestedEffectChainPosition() const;
 
 
     /**
      * A touch point was pressed.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param pos The position of the touch point in global coordinates
      * @param time Timestamp
      *
      * @see touchMotion
      * @see touchUp
      * @since 5.8
      **/
     virtual bool touchDown(quint32 id, const QPointF &pos, quint32 time);
     /**
      * A touch point moved.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param pos The position of the touch point in global coordinates
      * @param time Timestamp
      *
      * @see touchDown
      * @see touchUp
      * @since 5.8
      **/
     virtual bool touchMotion(quint32 id, const QPointF &pos, quint32 time);
     /**
      * A touch point was released.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param time Timestamp
      *
      * @see touchDown
      * @see touchMotion
      * @since 5.8
      **/
     virtual bool touchUp(quint32 id, quint32 time);
 
     static QPoint cursorPos();
 
     /**
      * Read animation time from the configuration and possibly adjust using animationTimeFactor().
      * The configuration value in the effect should also have special value 'default' (set using
      * QSpinBox::setSpecialValueText()) with the value 0. This special value is adjusted
      * using the global animation speed, otherwise the exact time configured is returned.
      * @param cfg configuration group to read value from
      * @param key configuration key to read value from
      * @param defaultTime default animation time in milliseconds
      */
     // return type is intentionally double so that one can divide using it without losing data
     static double animationTime(const KConfigGroup& cfg, const QString& key, int defaultTime);
     /**
      * @overload Use this variant if the animation time is hardcoded and not configurable
      * in the effect itself.
      */
     static double animationTime(int defaultTime);
     /**
      * @overload Use this variant if animation time is provided through a KConfigXT generated class
      * having a property called "duration".
      **/
     template <typename T>
     int animationTime(int defaultDuration);
     /**
      * Linearly interpolates between @p x and @p y.
      *
      * Returns @p x when @p a = 0; returns @p y when @p a = 1.
      **/
     static double interpolate(double x, double y, double a) {
         return x * (1 - a) + y * a;
     }
     /** Helper to set WindowPaintData and QRegion to necessary transformations so that
      * a following drawWindow() would put the window at the requested geometry (useful for thumbnails)
      **/
     static void setPositionTransformations(WindowPaintData& data, QRect& region, EffectWindow* w,
                                            const QRect& r, Qt::AspectRatioMode aspect);
 
 public Q_SLOTS:
     virtual bool borderActivated(ElectricBorder border);
 
 protected:
     xcb_connection_t *xcbConnection() const;
     xcb_window_t x11RootWindow() const;
 };
 
 
 /**
  * Prefer the KWIN_EFFECT_FACTORY macros.
  */
 class KWINEFFECTS_EXPORT EffectPluginFactory : public KPluginFactory
 {
     Q_OBJECT
 public:
     EffectPluginFactory();
     virtual ~EffectPluginFactory();
     /**
      * Returns whether the Effect is supported.
      *
      * An Effect can implement this method to determine at runtime whether the Effect is supported.
      *
      * If the current compositing backend is not supported it should return @c false.
      *
      * This method is optional, by default @c true is returned.
      */
     virtual bool isSupported() const;
     /**
      * Returns whether the Effect should get enabled by default.
      *
      * This function provides a way for an effect to override the default at runtime,
      * e.g. based on the capabilities of the hardware.
      *
      * This method is optional; the effect doesn't have to provide it.
      *
      * Note that this function is only called if the supported() function returns true,
      * and if X-KDE-PluginInfo-EnabledByDefault is set to true in the .desktop file.
      *
      * This method is optional, by default @c true is returned.
      */
     virtual bool enabledByDefault() const;
     /**
      * This method returns the created Effect.
      */
     virtual KWin::Effect *createEffect() const = 0;
 };
 
 /**
  * Defines an EffectPluginFactory sub class with customized isSupported and enabledByDefault methods.
  *
  * If the Effect to be created does not need the isSupported or enabledByDefault methods prefer
  * the simplified KWIN_EFFECT_FACTORY, KWIN_EFFECT_FACTORY_SUPPORTED or KWIN_EFFECT_FACTORY_ENABLED
  * macros which create an EffectPluginFactory with a useable default value.
  *
  * The macro also adds a useable K_EXPORT_PLUGIN_VERSION to the definition. KWin will not load
  * any Effect with a non-matching plugin version. This API is not providing binary compatibility
  * and thus the effect plugin must be compiled against the same kwineffects library version as
  * KWin.
  *
  * @param factoryName The name to be used for the EffectPluginFactory
  * @param className The class name of the Effect sub class which is to be created by the factory
  * @param jsonFile Name of the json file to be compiled into the plugin as metadata
  * @param supported Source code to go into the isSupported() method, must return a boolean
  * @param enabled Source code to go into the enabledByDefault() method, must return a boolean
  **/
 #define KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, supported, enabled ) \
     class factoryName : public KWin::EffectPluginFactory \
     { \
         Q_OBJECT \
         Q_PLUGIN_METADATA(IID KPluginFactory_iid FILE jsonFile) \
         Q_INTERFACES(KPluginFactory) \
     public: \
         explicit factoryName() {} \
         ~factoryName() {} \
         bool isSupported() const override { \
             supported \
         } \
         bool enabledByDefault() const override { \
             enabled \
         } \
         KWin::Effect *createEffect() const override { \
             return new className(); \
         } \
     }; \
     K_EXPORT_PLUGIN_VERSION(quint32(KWIN_EFFECT_API_VERSION))
 
 #define KWIN_EFFECT_FACTORY_ENABLED( factoryName, className, jsonFile, enabled ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, return true;, enabled )
 
 #define KWIN_EFFECT_FACTORY_SUPPORTED( factoryName, classname, jsonFile, supported ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, supported, return true; )
 
 #define KWIN_EFFECT_FACTORY( factoryName, classname, jsonFile ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, return true;, return true; )
 
 
 
 /**
  * @short Manager class that handles all the effects.
  *
  * This class creates Effect objects and calls it's appropriate methods.
  *
  * Effect objects can call methods of this class to interact with the
  *  workspace, e.g. to activate or move a specific window, change current
  *  desktop or create a special input window to receive mouse and keyboard
  *  events.
  **/
 class KWINEFFECTS_EXPORT EffectsHandler : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(int currentDesktop READ currentDesktop WRITE setCurrentDesktop NOTIFY desktopChanged)
     Q_PROPERTY(QString currentActivity READ currentActivity NOTIFY currentActivityChanged)
     Q_PROPERTY(KWin::EffectWindow *activeWindow READ activeWindow WRITE activateWindow NOTIFY windowActivated)
     Q_PROPERTY(QSize desktopGridSize READ desktopGridSize)
     Q_PROPERTY(int desktopGridWidth READ desktopGridWidth)
     Q_PROPERTY(int desktopGridHeight READ desktopGridHeight)
     Q_PROPERTY(int workspaceWidth READ workspaceWidth)
     Q_PROPERTY(int workspaceHeight READ workspaceHeight)
     /**
      * The number of desktops currently used. Minimum number of desktops is 1, maximum 20.
      **/
     Q_PROPERTY(int desktops READ numberOfDesktops WRITE setNumberOfDesktops NOTIFY numberDesktopsChanged)
     Q_PROPERTY(bool optionRollOverDesktops READ optionRollOverDesktops)
     Q_PROPERTY(int activeScreen READ activeScreen)
     Q_PROPERTY(int numScreens READ numScreens NOTIFY numberScreensChanged)
     /**
      * Factor by which animation speed in the effect should be modified (multiplied).
      * If configurable in the effect itself, the option should have also 'default'
      * animation speed. The actual value should be determined using animationTime().
      * Note: The factor can be also 0, so make sure your code can cope with 0ms time
      * if used manually.
      */
     Q_PROPERTY(qreal animationTimeFactor READ animationTimeFactor)
     Q_PROPERTY(QList< KWin::EffectWindow* > stackingOrder READ stackingOrder)
     /**
      * Whether window decorations use the alpha channel.
      **/
     Q_PROPERTY(bool decorationsHaveAlpha READ decorationsHaveAlpha)
     /**
      * Whether the window decorations support blurring behind the decoration.
      **/
     Q_PROPERTY(bool decorationSupportsBlurBehind READ decorationSupportsBlurBehind)
     Q_PROPERTY(CompositingType compositingType READ compositingType CONSTANT)
     Q_PROPERTY(QPoint cursorPos READ cursorPos)
     Q_PROPERTY(QSize virtualScreenSize READ virtualScreenSize NOTIFY virtualScreenSizeChanged)
     Q_PROPERTY(QRect virtualScreenGeometry READ virtualScreenGeometry NOTIFY virtualScreenGeometryChanged)
     friend class Effect;
 public:
     explicit EffectsHandler(CompositingType type);
     virtual ~EffectsHandler();
     // for use by effects
     virtual void prePaintScreen(ScreenPrePaintData& data, int time) = 0;
     virtual void paintScreen(int mask, QRegion region, ScreenPaintData& data) = 0;
     virtual void postPaintScreen() = 0;
     virtual void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) = 0;
     virtual void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) = 0;
     virtual void postPaintWindow(EffectWindow* w) = 0;
     virtual void paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity) = 0;
     virtual void drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) = 0;
     virtual void buildQuads(EffectWindow* w, WindowQuadList& quadList) = 0;
     virtual QVariant kwinOption(KWinOption kwopt) = 0;
     /**
      * Sets the cursor while the mouse is intercepted.
      * @see startMouseInterception
      * @since 4.11
      **/
     virtual void defineCursor(Qt::CursorShape shape) = 0;
     virtual QPoint cursorPos() const = 0;
     virtual bool grabKeyboard(Effect* effect) = 0;
     virtual void ungrabKeyboard() = 0;
     /**
      * Ensures that all mouse events are sent to the @p effect.
      * No window will get the mouse events. Only fullscreen effects providing a custom user interface should
      * be using this method. The input events are delivered to Effect::windowInputMouseEvent.
      *
      * NOTE: this method does not perform an X11 mouse grab. On X11 a fullscreen input window is raised above
      * all other windows, but no grab is performed.
      *
      * @param shape Sets the cursor to be used while the mouse is intercepted
      * @see stopMouseInterception
      * @see Effect::windowInputMouseEvent
      * @since 4.11
      **/
     virtual void startMouseInterception(Effect *effect, Qt::CursorShape shape) = 0;
     /**
      * Releases the hold mouse interception for @p effect
      * @see startMouseInterception
      * @since 4.11
      **/
     virtual void stopMouseInterception(Effect *effect) = 0;
 
     /**
      * @brief Registers a global shortcut with the provided @p action.
      *
      * @param shortcut The global shortcut which should trigger the action
      * @param action The action which gets triggered when the shortcut matches
      */
     virtual void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) = 0;
     /**
      * @brief Registers a global pointer shortcut with the provided @p action.
      *
      * @param modifiers The keyboard modifiers which need to be holded
      * @param pointerButtons The pointer buttons which need to be pressed
      * @param action The action which gets triggered when the shortcut matches
      **/
     virtual void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) = 0;
     /**
      * @brief Registers a global axis shortcut with the provided @p action.
      *
      * @param modifiers The keyboard modifiers which need to be holded
      * @param axis The direction in which the axis needs to be moved
      * @param action The action which gets triggered when the shortcut matches
      **/
     virtual void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) = 0;
 
     /**
      * Retrieve the proxy class for an effect if it has one. Will return NULL if
      * the effect isn't loaded or doesn't have a proxy class.
      */
     virtual void* getProxy(QString name) = 0;
 
     // Mouse polling
     virtual void startMousePolling() = 0;
     virtual void stopMousePolling() = 0;
 
     virtual void reserveElectricBorder(ElectricBorder border, Effect *effect) = 0;
     virtual void unreserveElectricBorder(ElectricBorder border, Effect *effect) = 0;
 
     // functions that allow controlling windows/desktop
     virtual void activateWindow(KWin::EffectWindow* c) = 0;
     virtual KWin::EffectWindow* activeWindow() const = 0 ;
     Q_SCRIPTABLE virtual void moveWindow(KWin::EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) = 0;
     Q_SCRIPTABLE virtual void windowToDesktop(KWin::EffectWindow* w, int desktop) = 0;
     Q_SCRIPTABLE virtual void windowToScreen(KWin::EffectWindow* w, int screen) = 0;
     virtual void setShowingDesktop(bool showing) = 0;
 
 
     // Activities
     /**
      * @returns The ID of the current activity.
      */
     virtual QString currentActivity() const = 0;
     // Desktops
     /**
      * @returns The ID of the current desktop.
      */
     virtual int currentDesktop() const = 0;
     /**
      * @returns Total number of desktops currently in existence.
      */
     virtual int numberOfDesktops() const = 0;
     /**
      * Set the current desktop to @a desktop.
      */
     virtual void setCurrentDesktop(int desktop) = 0;
     /**
     * Sets the total number of desktops to @a desktops.
     */
     virtual void setNumberOfDesktops(int desktops) = 0;
     /**
      * @returns The size of desktop layout in grid units.
      */
     virtual QSize desktopGridSize() const = 0;
     /**
      * @returns The width of desktop layout in grid units.
      */
     virtual int desktopGridWidth() const = 0;
     /**
      * @returns The height of desktop layout in grid units.
      */
     virtual int desktopGridHeight() const = 0;
     /**
      * @returns The width of desktop layout in pixels.
      */
     virtual int workspaceWidth() const = 0;
     /**
      * @returns The height of desktop layout in pixels.
      */
     virtual int workspaceHeight() const = 0;
     /**
      * @returns The ID of the desktop at the point @a coords or 0 if no desktop exists at that
      * point. @a coords is to be in grid units.
      */
     virtual int desktopAtCoords(QPoint coords) const = 0;
     /**
      * @returns The coords of desktop @a id in grid units.
      */
     virtual QPoint desktopGridCoords(int id) const = 0;
     /**
      * @returns The coords of the top-left corner of desktop @a id in pixels.
      */
     virtual QPoint desktopCoords(int id) const = 0;
     /**
      * @returns The ID of the desktop above desktop @a id. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopAbove(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop to the right of desktop @a id. Wraps around to the
      * left of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopToRight(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop below desktop @a id. Wraps around to the top of the
      * layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopBelow(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop to the left of desktop @a id. Wraps around to the
      * right of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopToLeft(int desktop = 0, bool wrap = true) const = 0;
     Q_SCRIPTABLE virtual QString desktopName(int desktop) const = 0;
     virtual bool optionRollOverDesktops() const = 0;
 
     virtual int activeScreen() const = 0; // Xinerama
     virtual int numScreens() const = 0; // Xinerama
     Q_SCRIPTABLE virtual int screenNumber(const QPoint& pos) const = 0;   // Xinerama
     virtual QRect clientArea(clientAreaOption, int screen, int desktop) const = 0;
     virtual QRect clientArea(clientAreaOption, const EffectWindow* c) const = 0;
     virtual QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const = 0;
 
     /**
      * The bounding size of all screens combined. Overlapping areas
      * are not counted multiple times.
      *
      * @see virtualScreenGeometry()
      * @see virtualScreenSizeChanged()
      * @since 5.0
      **/
     virtual QSize virtualScreenSize() const = 0;
     /**
      * The bounding geometry of all outputs combined. Always starts at (0,0) and has
      * virtualScreenSize as it's size.
      *
      * @see virtualScreenSize()
      * @see virtualScreenGeometryChanged()
      * @since 5.0
      **/
     virtual QRect virtualScreenGeometry() const = 0;
     /**
      * Factor by which animation speed in the effect should be modified (multiplied).
      * If configurable in the effect itself, the option should have also 'default'
      * animation speed. The actual value should be determined using animationTime().
      * Note: The factor can be also 0, so make sure your code can cope with 0ms time
      * if used manually.
      */
     virtual double animationTimeFactor() const = 0;
     virtual WindowQuadType newWindowQuadType() = 0;
 
     Q_SCRIPTABLE virtual KWin::EffectWindow* findWindow(WId id) const = 0;
     Q_SCRIPTABLE virtual KWin::EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const = 0;
     virtual EffectWindowList stackingOrder() const = 0;
     // window will be temporarily painted as if being at the top of the stack
     Q_SCRIPTABLE virtual void setElevatedWindow(KWin::EffectWindow* w, bool set) = 0;
 
     virtual void setTabBoxWindow(EffectWindow*) = 0;
     virtual void setTabBoxDesktop(int) = 0;
     virtual EffectWindowList currentTabBoxWindowList() const = 0;
     virtual void refTabBox() = 0;
     virtual void unrefTabBox() = 0;
     virtual void closeTabBox() = 0;
     virtual QList< int > currentTabBoxDesktopList() const = 0;
     virtual int currentTabBoxDesktop() const = 0;
     virtual EffectWindow* currentTabBoxWindow() const = 0;
 
     virtual void setActiveFullScreenEffect(Effect* e) = 0;
     virtual Effect* activeFullScreenEffect() const = 0;
 
     /**
      * Schedules the entire workspace to be repainted next time.
      * If you call it during painting (including prepaint) then it does not
      *  affect the current painting.
      **/
     Q_SCRIPTABLE virtual void addRepaintFull() = 0;
     Q_SCRIPTABLE virtual void addRepaint(const QRect& r) = 0;
     Q_SCRIPTABLE virtual void addRepaint(const QRegion& r) = 0;
     Q_SCRIPTABLE virtual void addRepaint(int x, int y, int w, int h) = 0;
 
     CompositingType compositingType() const;
     /**
      * @brief Whether the Compositor is OpenGL based (either GL 1 or 2).
      *
      * @return bool @c true in case of OpenGL based Compositor, @c false otherwise
      **/
     bool isOpenGLCompositing() const;
     virtual unsigned long xrenderBufferPicture() = 0;
     /**
      * @brief Provides access to the QPainter which is rendering to the back buffer.
      *
      * Only relevant for CompositingType QPainterCompositing. For all other compositing types
      * @c null is returned.
      *
      * @return QPainter* The Scene's QPainter or @c null.
      */
     virtual QPainter *scenePainter() = 0;
     virtual void reconfigure() = 0;
 
     virtual QByteArray readRootProperty(long atom, long type, int format) const = 0;
     /**
      * @brief Announces support for the feature with the given name. If no other Effect
      * has announced support for this feature yet, an X11 property will be installed on
      * the root window.
      *
      * The Effect will be notified for events through the signal propertyNotify().
      *
      * To remove the support again use @link removeSupportProperty. When an Effect is
      * destroyed it is automatically taken care of removing the support. It is not
      * required to call @link removeSupportProperty in the Effect's cleanup handling.
      *
      * @param propertyName The name of the property to announce support for
      * @param effect The effect which announces support
      * @return xcb_atom_t The created X11 atom
      * @see removeSupportProperty
      * @since 4.11
      **/
     virtual xcb_atom_t announceSupportProperty(const QByteArray &propertyName, Effect *effect) = 0;
     /**
      * @brief Removes support for the feature with the given name. If there is no other Effect left
      * which has announced support for the given property, the property will be removed from the
      * root window.
      *
      * In case the Effect had not registered support, calling this function does not change anything.
      *
      * @param propertyName The name of the property to remove support for
      * @param effect The effect which had registered the property.
      * @see announceSupportProperty
      * @since 4.11
      **/
     virtual void removeSupportProperty(const QByteArray &propertyName, Effect *effect) = 0;
 
     /**
      * Returns @a true if the active window decoration has shadow API hooks.
      */
     virtual bool hasDecorationShadows() const = 0;
 
     /**
      * Returns @a true if the window decorations use the alpha channel, and @a false otherwise.
      * @since 4.5
      */
     virtual bool decorationsHaveAlpha() const = 0;
 
     /**
      * Returns @a true if the window decorations support blurring behind the decoration, and @a false otherwise
      * @since 4.6
      */
     virtual bool decorationSupportsBlurBehind() const = 0;
 
     /**
      * Creates a new frame object. If the frame does not have a static size
      * then it will be located at @a position with @a alignment. A
      * non-static frame will automatically adjust its size to fit the contents.
      * @returns A new @ref EffectFrame. It is the responsibility of the caller to delete the
      * EffectFrame.
      * @since 4.6
      */
     virtual EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize = true,
                                      const QPoint& position = QPoint(-1, -1), Qt::Alignment alignment = Qt::AlignCenter) const = 0;
 
     /**
      * Allows an effect to trigger a reload of itself.
      * This can be used by an effect which needs to be reloaded when screen geometry changes.
      * It is possible that the effect cannot be loaded again as it's supported method does no longer
      * hold.
      * @param effect The effect to reload
      * @since 4.8
      **/
     virtual void reloadEffect(Effect *effect) = 0;
 
     /**
      * Whether the screen is currently considered as locked.
      * Note for technical reasons this is not always possible to detect. The screen will only
      * be considered as locked if the screen locking process implements the
      * org.freedesktop.ScreenSaver interface.
      *
      * @returns @c true if the screen is currently locked, @c false otherwise
      * @see screenLockingChanged
      * @since 4.11
      **/
     virtual bool isScreenLocked() const = 0;
 
     /**
      * @brief Makes the OpenGL compositing context current.
      *
      * If the compositing backend is not using OpenGL, this method returns @c false.
      *
      * @return bool @c true if the context became current, @c false otherwise.
      */
     virtual bool makeOpenGLContextCurrent() = 0;
     /**
      * @brief Makes a null OpenGL context current resulting in no context
      * being current.
      *
      * If the compositing backend is not OpenGL based, this method is a noop.
      *
      * There is normally no reason for an Effect to call this method.
      */
     virtual void doneOpenGLContextCurrent() = 0;
 
     virtual xcb_connection_t *xcbConnection() const = 0;
     virtual xcb_window_t x11RootWindow() const = 0;
 
     /**
      * Interface to the Wayland display: this is relevant only
      * on Wayland, on X11 it will be nullptr
      * @since 5.5
      */
     virtual KWayland::Server::Display *waylandDisplay() const = 0;
 
     /**
      * Whether animations are supported by the Scene.
      * If this method returns @c false Effects are supposed to not
      * animate transitions.
      *
      * @returns Whether the Scene can drive animations
      * @since 5.8
      **/
     virtual bool animationsSupported() const = 0;
 
     /**
      * The current cursor image of the Platform.
      * @see cursorPos
      * @since 5.9
      **/
     virtual PlatformCursorImage cursorImage() const = 0;
 
     /**
      * The cursor image should be hidden.
      * @see showCursor
      * @since 5.9
      **/
     virtual void hideCursor() = 0;
 
     /**
      * The cursor image should be shown again after having been hidden..
      * @see hideCursor
      * @since 5.9
      **/
     virtual void showCursor() = 0;
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected EffectWindow as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @since 5.9
      **/
     virtual void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) = 0;
 
+    /**
+     * Starts an interactive position selection process.
+     *
+     * Once the user selected a position on the screen the @p callback is invoked with
+     * the selected point as argument. In case the user cancels the interactive position selection
+     * or selecting a position is currently not possible (e.g. screen locked) the @p callback
+     * is invoked with a point at @c -1 as x and y argument.
+     *
+     * During the interactive window selection the cursor is turned into a crosshair cursor.
+     *
+     * @param callback The function to invoke once the interactive position selection ends
+     * @since 5.9
+     **/
+    virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) = 0;
+
 Q_SIGNALS:
     /**
      * Signal emitted when the current desktop changed.
      * @param oldDesktop The previously current desktop
      * @param newDesktop The new current desktop
      * @param with The window which is taken over to the new desktop, can be NULL
      * @since 4.9
      */
     void desktopChanged(int oldDesktop, int newDesktop, KWin::EffectWindow *with);
     /**
      * @since 4.7
      * @deprecated
      */
     void desktopChanged(int oldDesktop, int newDesktop);
     /**
      * Signal emitted when a window moved to another desktop
      * NOTICE that this does NOT imply that the desktop has changed
      * The @param window which is moved to the new desktop
      * @param oldDesktop The previous desktop of the window
      * @param newDesktop The new desktop of the window
      * @since 4.11.4
      */
     void desktopPresenceChanged(KWin::EffectWindow *window, int oldDesktop, int newDesktop);
     /**
     * Signal emitted when the number of currently existing desktops is changed.
     * @param old The previous number of desktops in used.
     * @see EffectsHandler::numberOfDesktops.
     * @since 4.7
     */
     void numberDesktopsChanged(uint old);
     /**
      * Signal emitted when the number of screens changed.
      * @since 5.0
      **/
     void numberScreensChanged();
     /**
      * Signal emitted when the desktop showing ("dashboard") state changed
      * The desktop is risen to the keepAbove layer, you may want to elevate
      * windows or such.
      * @since 5.3
      **/
     void showingDesktopChanged(bool);
     /**
      * Signal emitted when a new window has been added to the Workspace.
      * @param w The added window
      * @since 4.7
      **/
     void windowAdded(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window is being removed from the Workspace.
      * An effect which wants to animate the window closing should connect
      * to this signal and reference the window by using
      * @link EffectWindow::refWindow
      * @param w The window which is being closed
      * @since 4.7
      **/
     void windowClosed(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window get's activated.
      * @param w The new active window, or @c NULL if there is no active window.
      * @since 4.7
      **/
     void windowActivated(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window is deleted.
      * This means that a closed window is not referenced any more.
      * An effect bookkeeping the closed windows should connect to this
      * signal to clean up the internal references.
      * @param w The window which is going to be deleted.
      * @see EffectWindow::refWindow
      * @see EffectWindow::unrefWindow
      * @see windowClosed
      * @since 4.7
      **/
     void windowDeleted(KWin::EffectWindow *w);
     /**
      * Signal emitted when a user begins a window move or resize operation.
      * To figure out whether the user resizes or moves the window use
      * @link EffectWindow::isUserMove or @link EffectWindow::isUserResize.
      * Whenever the geometry is updated the signal @link windowStepUserMovedResized
      * is emitted with the current geometry.
      * The move/resize operation ends with the signal @link windowFinishUserMovedResized.
      * Only one window can be moved/resized by the user at the same time!
      * @param w The window which is being moved/resized
      * @see windowStepUserMovedResized
      * @see windowFinishUserMovedResized
      * @see EffectWindow::isUserMove
      * @see EffectWindow::isUserResize
      * @since 4.7
      **/
     void windowStartUserMovedResized(KWin::EffectWindow *w);
     /**
      * Signal emitted during a move/resize operation when the user changed the geometry.
      * Please note: KWin supports two operation modes. In one mode all changes are applied
      * instantly. This means the window's geometry matches the passed in @p geometry. In the
      * other mode the geometry is changed after the user ended the move/resize mode.
      * The @p geometry differs from the window's geometry. Also the window's pixmap still has
      * the same size as before. Depending what the effect wants to do it would be recommended
      * to scale/translate the window.
      * @param w The window which is being moved/resized
      * @param geometry The geometry of the window in the current move/resize step.
      * @see windowStartUserMovedResized
      * @see windowFinishUserMovedResized
      * @see EffectWindow::isUserMove
      * @see EffectWindow::isUserResize
      * @since 4.7
      **/
     void windowStepUserMovedResized(KWin::EffectWindow *w, const QRect &geometry);
     /**
      * Signal emitted when the user finishes move/resize of window @p w.
      * @param w The window which has been moved/resized
      * @see windowStartUserMovedResized
      * @see windowFinishUserMovedResized
      * @since 4.7
      **/
     void windowFinishUserMovedResized(KWin::EffectWindow *w);
     /**
      * Signal emitted when the maximized state of the window @p w changed.
      * A window can be in one of four states:
      * @li restored: both @p horizontal and @p vertical are @c false
      * @li horizontally maximized: @p horizontal is @c true and @p vertical is @c false
      * @li vertically maximized: @p horizontal is @c false and @p vertical is @c true
      * @li completely maximized: both @p horizontal and @p vertical are @C true
      * @param w The window whose maximized state changed
      * @param horizontal If @c true maximized horizontally
      * @param vertical If @c true maximized vertically
      * @since 4.7
      **/
     void windowMaximizedStateChanged(KWin::EffectWindow *w, bool horizontal, bool vertical);
     /**
      * Signal emitted when the geometry or shape of a window changed.
      * This is caused if the window changes geometry without user interaction.
      * E.g. the decoration is changed. This is in opposite to windowUserMovedResized
      * which is caused by direct user interaction.
      * @param w The window whose geometry changed
      * @param old The previous geometry
      * @see windowUserMovedResized
      * @since 4.7
      **/
     void windowGeometryShapeChanged(KWin::EffectWindow *w, const QRect &old);
     /**
      * Signal emitted when the padding of a window changed. (eg. shadow size)
      * @param w The window whose geometry changed
      * @param old The previous expandedGeometry()
      * @since 4.9
      **/
     void windowPaddingChanged(KWin::EffectWindow *w, const QRect &old);
     /**
      * Signal emitted when the windows opacity is changed.
      * @param w The window whose opacity level is changed.
      * @param oldOpacity The previous opacity level
      * @param newOpacity The new opacity level
      * @since 4.7
      **/
     void windowOpacityChanged(KWin::EffectWindow *w, qreal oldOpacity, qreal newOpacity);
     /**
      * Signal emitted when a window got minimized.
      * @param w The window which was minimized
      * @since 4.7
      **/
     void windowMinimized(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window got unminimized.
      * @param w The window which was unminimized
      * @since 4.7
      **/
     void windowUnminimized(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window either becomes modal (ie. blocking for its main client) or looses that state.
      * @param w The window which was unminimized
      * @since 4.11
      **/
     void windowModalityChanged(KWin::EffectWindow *w);
     /**
      * Signal emitted when an area of a window is scheduled for repainting.
      * Use this signal in an effect if another area needs to be synced as well.
      * @param w The window which is scheduled for repainting
      * @param r Always empty.
      * @since 4.7
      **/
     void windowDamaged(KWin::EffectWindow *w, const QRect &r);
     /**
      * Signal emitted when a tabbox is added.
      * An effect who wants to replace the tabbox with itself should use @link refTabBox.
      * @param mode The TabBoxMode.
      * @see refTabBox
      * @see tabBoxClosed
      * @see tabBoxUpdated
      * @see tabBoxKeyEvent
      * @since 4.7
      **/
     void tabBoxAdded(int mode);
     /**
      * Signal emitted when the TabBox was closed by KWin core.
      * An effect which referenced the TabBox should use @link unrefTabBox to unref again.
      * @see unrefTabBox
      * @see tabBoxAdded
      * @since 4.7
      **/
     void tabBoxClosed();
     /**
      * Signal emitted when the selected TabBox window changed or the TabBox List changed.
      * An effect should only response to this signal if it referenced the TabBox with @link refTabBox.
      * @see refTabBox
      * @see currentTabBoxWindowList
      * @see currentTabBoxDesktopList
      * @see currentTabBoxWindow
      * @see currentTabBoxDesktop
      * @since 4.7
      **/
     void tabBoxUpdated();
     /**
      * Signal emitted when a key event, which is not handled by TabBox directly is, happens while
      * TabBox is active. An effect might use the key event to e.g. change the selected window.
      * An effect should only response to this signal if it referenced the TabBox with @link refTabBox.
      * @param event The key event not handled by TabBox directly
      * @see refTabBox
      * @since 4.7
      **/
     void tabBoxKeyEvent(QKeyEvent* event);
     void currentTabAboutToChange(KWin::EffectWindow* from, KWin::EffectWindow* to);
     void tabAdded(KWin::EffectWindow* from, KWin::EffectWindow* to);   // from merged with to
     void tabRemoved(KWin::EffectWindow* c, KWin::EffectWindow* group);   // c removed from group
     /**
      * Signal emitted when mouse changed.
      * If an effect needs to get updated mouse positions, it needs to first call @link startMousePolling.
      * For a fullscreen effect it is better to use an input window and react on @link windowInputMouseEvent.
      * @param pos The new mouse position
      * @param oldpos The previously mouse position
      * @param buttons The pressed mouse buttons
      * @param oldbuttons The previously pressed mouse buttons
      * @param modifiers Pressed keyboard modifiers
      * @param oldmodifiers Previously pressed keyboard modifiers.
      * @see startMousePolling
      * @since 4.7
      **/
     void mouseChanged(const QPoint& pos, const QPoint& oldpos,
                               Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
                               Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers);
     /**
      * Signal emitted when the cursor shape changed.
      * You'll likely want to query the current cursor as reaction: xcb_xfixes_get_cursor_image_unchecked
      * Connection to this signal is tracked, so if you don't need it anymore, disconnect from it to stop cursor event filtering
      */
     void cursorShapeChanged();
     /**
      * Receives events registered for using @link registerPropertyType.
      * Use readProperty() to get the property data.
      * Note that the property may be already set on the window, so doing the same
      * processing from windowAdded() (e.g. simply calling propertyNotify() from it)
      * is usually needed.
      * @param w The window whose property changed, is @c null if it is a root window property
      * @param atom The property
      * @since 4.7
      */
     void propertyNotify(KWin::EffectWindow* w, long atom);
 
     /**
      * Signal emitted after the screen geometry changed (e.g. add of a monitor).
      * Effects using displayWidth()/displayHeight() to cache information should
      * react on this signal and update the caches.
      * @param size The new screen size
      * @since 4.8
      **/
     void screenGeometryChanged(const QSize &size);
 
     /**
      * This signal is emitted when the global
      * activity is changed
      * @param id id of the new current activity
      * @since 4.9
      **/
     void currentActivityChanged(const QString &id);
     /**
      * This signal is emitted when a new activity is added
      * @param id id of the new activity
      * @since 4.9
      */
     void activityAdded(const QString &id);
     /**
      * This signal is emitted when the activity
      * is removed
      * @param id id of the removed activity
      * @since 4.9
      */
     void activityRemoved(const QString &id);
     /**
      * This signal is emitted when the screen got locked or unlocked.
      * @param locked @c true if the screen is now locked, @c false if it is now unlocked
      * @since 4.11
      **/
     void screenLockingChanged(bool locked);
 
     /**
      * This signels is emitted when ever the stacking order is change, ie. a window is risen
      * or lowered
      * @since 4.10
      */
     void stackingOrderChanged();
     /**
      * This signal is emitted when the user starts to approach the @p border with the mouse.
      * The @p factor describes how far away the mouse is in a relative mean. The values are in
      * [0.0, 1.0] with 0.0 being emitted when first entered and on leaving. The value 1.0 means that
      * the @p border is reached with the mouse. So the values are well suited for animations.
      * The signal is always emitted when the mouse cursor position changes.
      * @param border The screen edge which is being approached
      * @param factor Value in range [0.0,1.0] to describe how close the mouse is to the border
      * @param geometry The geometry of the edge which is being approached
      * @since 4.11
      **/
     void screenEdgeApproaching(ElectricBorder border, qreal factor, const QRect &geometry);
     /**
      * Emitted whenever the virtualScreenSize changes.
      * @see virtualScreenSize()
      * @since 5.0
      **/
     void virtualScreenSizeChanged();
     /**
      * Emitted whenever the virtualScreenGeometry changes.
      * @see virtualScreenGeometry()
      * @since 5.0
      **/
     void virtualScreenGeometryChanged();
 
     /**
      * The window @p w gets shown again. The window was previously
      * initially shown with @link{windowAdded} and hidden with @link{windowHidden}.
      *
      * @see windowHidden
      * @see windowAdded
      * @since 5.8
      **/
     void windowShown(KWin::EffectWindow *w);
 
     /**
      * The window @p w got hidden but not yet closed.
      * This can happen when a window is still being used and is supposed to be shown again
      * with @link{windowShown}. On X11 an example is autohiding panels. On Wayland every
      * window first goes through the window hidden state and might get shown again, or might
      * get closed the normal way.
      *
      * @see windowShown
      * @see windowClosed
      * @since 5.8
      **/
     void windowHidden(KWin::EffectWindow *w);
 
     /**
      * This signal gets emitted when the data on EffectWindow @p w for @p role changed.
      *
      * An Effect can connect to this signal to read the new value and react on it.
      * E.g. an Effect which does not operate on windows grabbed by another Effect wants
      * to cancel the already scheduled animation if another Effect adds a grab.
      *
      * @param w The EffectWindow for which the data changed
      * @param role The data role which changed
      * @see EffectWindow::setData
      * @see EffectWindow::data
      * @since 5.8.4
      **/
     void windowDataChanged(KWin::EffectWindow *w, int role);
 
 protected:
     QVector< EffectPair > loaded_effects;
     //QHash< QString, EffectFactory* > effect_factories;
     CompositingType compositing_type;
 };
 
 
 /**
  * @short Representation of a window used by/for Effect classes.
  *
  * The purpose is to hide internal data and also to serve as a single
  *  representation for the case when Client/Unmanaged becomes Deleted.
  **/
 class KWINEFFECTS_EXPORT EffectWindow : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool alpha READ hasAlpha CONSTANT)
     Q_PROPERTY(QRect geometry READ geometry)
     Q_PROPERTY(QRect expandedGeometry READ expandedGeometry)
     Q_PROPERTY(int height READ height)
     Q_PROPERTY(qreal opacity READ opacity)
     Q_PROPERTY(QPoint pos READ pos)
     Q_PROPERTY(int screen READ screen)
     Q_PROPERTY(QSize size READ size)
     Q_PROPERTY(int width READ width)
     Q_PROPERTY(int x READ x)
     Q_PROPERTY(int y READ y)
     Q_PROPERTY(int desktop READ desktop)
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
     Q_PROPERTY(bool onCurrentDesktop READ isOnCurrentDesktop)
     Q_PROPERTY(QRect rect READ rect)
     Q_PROPERTY(QString windowClass READ windowClass)
     Q_PROPERTY(QString windowRole READ windowRole)
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool desktopWindow READ isDesktop)
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dock READ isDock)
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool toolbar READ isToolbar)
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool menu READ isMenu)
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool normalWindow READ isNormalWindow)
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dialog READ isDialog)
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool splash READ isSplash)
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool utility READ isUtility)
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dropdownMenu READ isDropdownMenu)
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool popupMenu READ isPopupMenu)
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool tooltip READ isTooltip)
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool notification READ isNotification)
     /**
      * Returns whether the window is an on screen display window
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_ON_SCREEN_DISPLAY
      */
     Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay)
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool comboBox READ isComboBox)
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dndIcon READ isDNDIcon)
     /**
      * Returns the NETWM window type
      * See http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(int windowType READ windowType)
     /**
      * Whether this EffectWindow is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      **/
     Q_PROPERTY(bool managed READ isManaged)
     /**
      * Whether this EffectWindow represents an already deleted window and only kept for the compositor for animations.
      **/
     Q_PROPERTY(bool deleted READ isDeleted)
     /**
      * Whether the window has an own shape
      **/
     Q_PROPERTY(bool shaped READ hasOwnShape)
     /**
      * The Window's shape
      **/
     Q_PROPERTY(QRegion shape READ shape)
     /**
      * The Caption of the window. Read from WM_NAME property together with a suffix for hostname and shortcut.
      **/
     Q_PROPERTY(QString caption READ caption)
     /**
      * Whether the window is set to be kept above other windows.
      **/
     Q_PROPERTY(bool keepAbove READ keepAbove)
     /**
      * Whether the window is minimized.
      **/
     Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized)
     /**
      * Whether the window represents a modal window.
      **/
     Q_PROPERTY(bool modal READ isModal)
     /**
      * Whether the window is moveable. Even if it is not moveable, it might be possible to move
      * it to another screen.
      * @see moveableAcrossScreens
      **/
     Q_PROPERTY(bool moveable READ isMovable)
     /**
      * Whether the window can be moved to another screen.
      * @see moveable
      **/
     Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
     /**
      * By how much the window wishes to grow/shrink at least. Usually QSize(1,1).
      * MAY BE DISOBEYED BY THE WM! It's only for information, do NOT rely on it at all.
      */
     Q_PROPERTY(QSize basicUnit READ basicUnit)
     /**
      * Whether the window is currently being moved by the user.
      **/
     Q_PROPERTY(bool move READ isUserMove)
     /**
      * Whether the window is currently being resized by the user.
      **/
     Q_PROPERTY(bool resize READ isUserResize)
     /**
      * The optional geometry representing the minimized Client in e.g a taskbar.
      * See _NET_WM_ICON_GEOMETRY at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      **/
     Q_PROPERTY(QRect iconGeometry READ iconGeometry)
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      **/
     Q_PROPERTY(bool specialWindow READ isSpecialWindow)
     Q_PROPERTY(QIcon icon READ icon)
     /**
      * Whether the window should be excluded from window switching effects.
      **/
     Q_PROPERTY(bool skipSwitcher READ isSkipSwitcher)
     /**
      * Geometry of the actual window contents inside the whole (including decorations) window.
      */
     Q_PROPERTY(QRect contentsRect READ contentsRect)
     /**
      * Geometry of the transparent rect in the decoration.
      * May be different from contentsRect if the decoration is extended into the client area.
      */
     Q_PROPERTY(QRect decorationInnerRect READ decorationInnerRect)
     Q_PROPERTY(bool hasDecoration READ hasDecoration)
     Q_PROPERTY(QStringList activities READ activities)
     Q_PROPERTY(bool onCurrentActivity READ isOnCurrentActivity)
     Q_PROPERTY(bool onAllActivities READ isOnAllActivities)
     /**
      * Whether the decoration currently uses an alpha channel.
      * @since 4.10
      **/
     Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
     /**
      * Whether the window is currently visible to the user, that is:
      * <ul>
      * <li>Not minimized</li>
      * <li>On current desktop</li>
      * <li>On current activity</li>
      * </ul>
      * @since 4.11
      **/
     Q_PROPERTY(bool visible READ isVisible)
     /**
      * Whether the window does not want to be animated on window close.
      * In case this property is @c true it is not useful to start an animation on window close.
      * The window will not be visible, but the animation hooks are executed.
      * @since 5.0
      **/
     Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation)
 
     /**
      * Interface to the corresponding wayland surface.
      * relevant only in Wayland, on X11 it will be nullptr
      */
     Q_PROPERTY(KWayland::Server::SurfaceInterface *surface READ surface)
 
     /**
      * Whether the window is fullscreen.
      * @since 5.6
      **/
     Q_PROPERTY(bool fullScreen READ isFullScreen)
 public:
     /**  Flags explaining why painting should be disabled  */
     enum {
         /**  Window will not be painted  */
         PAINT_DISABLED                 = 1 << 0,
         /**  Window will not be painted because it is deleted  */
         PAINT_DISABLED_BY_DELETE       = 1 << 1,
         /**  Window will not be painted because of which desktop it's on  */
         PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
         /**  Window will not be painted because it is minimized  */
         PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
         /**  Window will not be painted because it is not the active window in a client group  */
         PAINT_DISABLED_BY_TAB_GROUP = 1 << 4,
         /**  Window will not be painted because it's not on the current activity  */
         PAINT_DISABLED_BY_ACTIVITY     = 1 << 5
     };
 
     explicit EffectWindow(QObject *parent = nullptr);
     virtual ~EffectWindow();
 
     virtual void enablePainting(int reason) = 0;
     virtual void disablePainting(int reason) = 0;
     virtual bool isPaintingEnabled() = 0;
     Q_SCRIPTABLE void addRepaint(const QRect& r);
     Q_SCRIPTABLE void addRepaint(int x, int y, int w, int h);
     Q_SCRIPTABLE void addRepaintFull();
     Q_SCRIPTABLE void addLayerRepaint(const QRect& r);
     Q_SCRIPTABLE void addLayerRepaint(int x, int y, int w, int h);
 
     virtual void refWindow() = 0;
     virtual void unrefWindow() = 0;
     bool isDeleted() const;
 
     bool isMinimized() const;
     double opacity() const;
     bool hasAlpha() const;
 
     bool isOnCurrentActivity() const;
     Q_SCRIPTABLE bool isOnActivity(QString id) const;
     bool isOnAllActivities() const;
     QStringList activities() const;
 
     bool isOnDesktop(int d) const;
     bool isOnCurrentDesktop() const;
     bool isOnAllDesktops() const;
     int desktop() const; // prefer isOnXXX()
 
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     /**
      * By how much the window wishes to grow/shrink at least. Usually QSize(1,1).
      * MAY BE DISOBEYED BY THE WM! It's only for information, do NOT rely on it at all.
      */
     QSize basicUnit() const;
     QRect geometry() const;
     /**
      * Geometry of the window including decoration and potentially shadows.
      * May be different from geometry() if the window has a shadow.
      * @since 4.9
      */
     QRect expandedGeometry() const;
     virtual QRegion shape() const = 0;
     int screen() const;
     /** @internal Do not use */
     bool hasOwnShape() const; // only for shadow effect, for now
     QPoint pos() const;
     QSize size() const;
     QRect rect() const;
     bool isMovable() const;
     bool isMovableAcrossScreens() const;
     bool isUserMove() const;
     bool isUserResize() const;
     QRect iconGeometry() const;
 
     /**
      * Geometry of the actual window contents inside the whole (including decorations) window.
      */
     QRect contentsRect() const;
     /**
      * Geometry of the transparent rect in the decoration.
      * May be different from contentsRect() if the decoration is extended into the client area.
      * @since 4.5
      */
     virtual QRect decorationInnerRect() const = 0;
     bool hasDecoration() const;
     bool decorationHasAlpha() const;
     virtual QByteArray readProperty(long atom, long type, int format) const = 0;
     virtual void deleteProperty(long atom) const = 0;
 
     QString caption() const;
     QIcon icon() const;
     QString windowClass() const;
     QString windowRole() const;
     virtual const EffectWindowGroup* group() const = 0;
 
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isDesktop() const;
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isDock() const;
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isToolbar() const;
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isMenu() const;
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient'
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      */
     bool isSpecialWindow() const;
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isDialog() const;
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isSplash() const;
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isUtility() const;
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isDropdownMenu() const;
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isPopupMenu() const; // a context popup, not dropdown, not torn-off
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isTooltip() const;
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isNotification() const;
     /**
      * Returns whether the window is an on screen display window
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_ON_SCREEN_DISPLAY
      */
     bool isOnScreenDisplay() const;
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isComboBox() const;
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     bool isDNDIcon() const;
     /**
      * Returns the NETWM window type
      * See http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     NET::WindowType windowType() const;
     /**
      * Returns whether the window is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      */
     bool isManaged() const; // whether it's managed or override-redirect
     /**
      * Returns whether or not the window can accept keyboard focus.
      */
     bool acceptsFocus() const;
     /**
      * Returns whether or not the window is kept above all other windows.
      */
     bool keepAbove() const;
 
     bool isModal() const;
     Q_SCRIPTABLE virtual KWin::EffectWindow* findModal() = 0;
     Q_SCRIPTABLE virtual QList<KWin::EffectWindow*> mainWindows() const = 0;
 
     /**
     * Returns whether the window should be excluded from window switching effects.
     * @since 4.5
     */
     bool isSkipSwitcher() const;
 
     /**
      * Returns the unmodified window quad list. Can also be used to force rebuilding.
      */
     virtual WindowQuadList buildQuads(bool force = false) const = 0;
 
     void setMinimized(bool minimize);
     void minimize();
     void unminimize();
     Q_SCRIPTABLE void closeWindow() const;
 
     bool isCurrentTab() const;
 
     /**
      * @since 4.11
      **/
     bool isVisible() const;
 
     /**
      * @since 5.0
      **/
     bool skipsCloseAnimation() const;
 
     /**
      * @since 5.5
      */
     KWayland::Server::SurfaceInterface *surface() const;
 
     /**
      * @since 5.6
      **/
     bool isFullScreen() const;
 
     /**
      * Can be used to by effects to store arbitrary data in the EffectWindow.
      *
      * Invoking this method will emit the signal EffectsHandler::windowDataChanged.
      * @see EffectsHandler::windowDataChanged
      */
     Q_SCRIPTABLE virtual void setData(int role, const QVariant &data) = 0;
     Q_SCRIPTABLE virtual QVariant data(int role) const = 0;
 
     /**
      * @brief References the previous window pixmap to prevent discarding.
      *
      * This method allows to reference the previous window pixmap in case that a window changed
      * its size, which requires a new window pixmap. By referencing the previous (and then outdated)
      * window pixmap an effect can for example cross fade the current window pixmap with the previous
      * one. This allows for smoother transitions for window geometry changes.
      *
      * If an effect calls this method on a window it also needs to call @link unreferencePreviousWindowPixmap
      * once it does no longer need the previous window pixmap.
      *
      * Note: the window pixmap is not kept forever even when referenced. If the geometry changes again, so that
      * a new window pixmap is created, the previous window pixmap will be exchanged with the current one. This
      * means it's still possible to have rendering glitches. An effect is supposed to track for itself the changes
      * to the window's geometry and decide how the transition should continue in such a situation.
      *
      * @see unreferencePreviousWindowPixmap
      * @since 4.11
      */
     virtual void referencePreviousWindowPixmap() = 0;
     /**
      * @brief Unreferences the previous window pixmap. Only relevant after @link referencePreviousWindowPixmap had
      * been called.
      *
      * @see referencePreviousWindowPixmap
      * @since 4.11
      */
     virtual void unreferencePreviousWindowPixmap() = 0;
 };
 
 class KWINEFFECTS_EXPORT EffectWindowGroup
 {
 public:
     virtual ~EffectWindowGroup();
     virtual EffectWindowList members() const = 0;
 };
 
 
 struct GLVertex2D
 {
     QVector2D position;
     QVector2D texcoord;
 };
 
 struct GLVertex3D
 {
     QVector3D position;
     QVector2D texcoord;
 };
 
 
 /**
  * @short Vertex class
  *
  * A vertex is one position in a window. WindowQuad consists of four WindowVertex objects
  * and represents one part of a window.
  **/
 class KWINEFFECTS_EXPORT WindowVertex
 {
 public:
     WindowVertex();
     WindowVertex(double x, double y, double tx, double ty);
 
     double x() const { return px; }
     double y() const { return py; }
     double u() const { return tx; }
     double v() const { return ty; }
     double originalX() const { return ox; }
     double originalY() const { return oy; }
     double textureX() const { return tx; }
     double textureY() const { return ty; }
     void move(double x, double y);
     void setX(double x);
     void setY(double y);
 
 private:
     friend class WindowQuad;
     friend class WindowQuadList;
     double px, py; // position
     double ox, oy; // origional position
     double tx, ty; // texture coords
 };
 
 /**
  * @short Class representing one area of a window.
  *
  * WindowQuads consists of four WindowVertex objects and represents one part of a window.
  */
 // NOTE: This class expects the (original) vertices to be in the clockwise order starting from topleft.
 class KWINEFFECTS_EXPORT WindowQuad
 {
 public:
     explicit WindowQuad(WindowQuadType type, int id = -1);
     WindowQuad makeSubQuad(double x1, double y1, double x2, double y2) const;
     WindowVertex& operator[](int index);
     const WindowVertex& operator[](int index) const;
     WindowQuadType type() const;
     void setUVAxisSwapped(bool value) { uvSwapped = value; }
     bool uvAxisSwapped() const { return uvSwapped; }
     int id() const;
     bool decoration() const;
     bool effect() const;
     double left() const;
     double right() const;
     double top() const;
     double bottom() const;
     double originalLeft() const;
     double originalRight() const;
     double originalTop() const;
     double originalBottom() const;
     bool smoothNeeded() const;
     bool isTransformed() const;
 private:
     friend class WindowQuadList;
     WindowVertex verts[ 4 ];
     WindowQuadType quadType; // 0 - contents, 1 - decoration
     bool uvSwapped;
     int quadID;
 };
 
 class KWINEFFECTS_EXPORT WindowQuadList
     : public QList< WindowQuad >
 {
 public:
     WindowQuadList splitAtX(double x) const;
     WindowQuadList splitAtY(double y) const;
     WindowQuadList makeGrid(int maxquadsize) const;
     WindowQuadList makeRegularGrid(int xSubdivisions, int ySubdivisions) const;
     WindowQuadList select(WindowQuadType type) const;
     WindowQuadList filterOut(WindowQuadType type) const;
     bool smoothNeeded() const;
     void makeInterleavedArrays(unsigned int type, GLVertex2D *vertices, const QMatrix4x4 &matrix) const;
     void makeArrays(float** vertices, float** texcoords, const QSizeF &size, bool yInverted) const;
     bool isTransformed() const;
 };
 
 class KWINEFFECTS_EXPORT WindowPrePaintData
 {
 public:
     int mask;
     /**
      * Region that will be painted, in screen coordinates.
      **/
     QRegion paint;
     /**
      * The clip region will be subtracted from paint region of following windows.
      * I.e. window will definitely cover it's clip region
      **/
     QRegion clip;
     WindowQuadList quads;
     /**
      * Simple helper that sets data to say the window will be painted as non-opaque.
      * Takes also care of changing the regions.
      */
     void setTranslucent();
     /**
      * Helper to mark that this window will be transformed
      **/
     void setTransformed();
 };
 
 class KWINEFFECTS_EXPORT PaintData
 {
 public:
     virtual ~PaintData();
     /**
      * @returns scale factor in X direction.
      * @since 4.10
      **/
     qreal xScale() const;
     /**
      * @returns scale factor in Y direction.
      * @since 4.10
      **/
     qreal yScale() const;
     /**
      * @returns scale factor in Z direction.
      * @since 4.10
      **/
     qreal zScale() const;
     /**
      * Sets the scale factor in X direction to @p scale
      * @param scale The scale factor in X direction
      * @since 4.10
      **/
     void setXScale(qreal scale);
     /**
      * Sets the scale factor in Y direction to @p scale
      * @param scale The scale factor in Y direction
      * @since 4.10
      **/
     void setYScale(qreal scale);
     /**
      * Sets the scale factor in Z direction to @p scale
      * @param scale The scale factor in Z direction
      * @since 4.10
      **/
     void setZScale(qreal scale);
     /**
      * Sets the scale factor in X and Y direction.
      * @param scale The scale factor for X and Y direction
      * @since 4.10
      **/
     void setScale(const QVector2D &scale);
     /**
      * Sets the scale factor in X, Y and Z direction
      * @param scale The scale factor for X, Y and Z direction
      * @since 4.10
      **/
     void setScale(const QVector3D &scale);
     const QGraphicsScale &scale() const;
     const QVector3D &translation() const;
     /**
      * @returns the translation in X direction.
      * @since 4.10
      **/
     qreal xTranslation() const;
     /**
      * @returns the translation in Y direction.
      * @since 4.10
      **/
     qreal yTranslation() const;
     /**
      * @returns the translation in Z direction.
      * @since 4.10
      **/
     qreal zTranslation() const;
     /**
      * Sets the translation in X direction to @p translate.
      * @since 4.10
      **/
     void setXTranslation(qreal translate);
     /**
      * Sets the translation in Y direction to @p translate.
      * @since 4.10
      **/
     void setYTranslation(qreal translate);
     /**
      * Sets the translation in Z direction to @p translate.
      * @since 4.10
      **/
     void setZTranslation(qreal translate);
     /**
      * Performs a translation by adding the values component wise.
      * @param x Translation in X direction
      * @param y Translation in Y direction
      * @param z Translation in Z direction
      * @since 4.10
      **/
     void translate(qreal x, qreal y = 0.0, qreal z = 0.0);
     /**
      * Performs a translation by adding the values component wise.
      * Overloaded method for convenience.
      * @param translate The translation
      * @since 4.10
      **/
     void translate(const QVector3D &translate);
 
     /**
      * Sets the rotation angle.
      * @param angle The new rotation angle.
      * @since 4.10
      * @see rotationAngle()
      **/
     void setRotationAngle(qreal angle);
     /**
      * Returns the rotation angle.
      * Initially 0.0.
      * @returns The current rotation angle.
      * @since 4.10
      * @see setRotationAngle
      **/
     qreal rotationAngle() const;
     /**
      * Sets the rotation origin.
      * @param origin The new rotation origin.
      * @since 4.10
      * @see rotationOrigin()
      **/
     void setRotationOrigin(const QVector3D &origin);
     /**
      * Returns the rotation origin. That is the point in space which is fixed during the rotation.
      * Initially this is 0/0/0.
      * @returns The rotation's origin
      * @since 4.10
      * @see setRotationOrigin()
      **/
     QVector3D rotationOrigin() const;
     /**
      * Sets the rotation axis.
      * Set a component to 1.0 to rotate around this axis and to 0.0 to disable rotation around the
      * axis.
      * @param axis A vector holding information on which axis to rotate
      * @since 4.10
      * @see rotationAxis()
      **/
     void setRotationAxis(const QVector3D &axis);
     /**
      * Sets the rotation axis.
      * Overloaded method for convenience.
      * @param axis The axis around which should be rotated.
      * @since 4.10
      * @see rotationAxis()
      **/
     void setRotationAxis(Qt::Axis axis);
     /**
      * The current rotation axis.
      * By default the rotation is (0/0/1) which means a rotation around the z axis.
      * @returns The current rotation axis.
      * @since 4.10
      * @see setRotationAxis
      **/
     QVector3D rotationAxis() const;
 
 protected:
     PaintData();
     PaintData(const PaintData &other);
 
 private:
     PaintDataPrivate * const d;
 };
 
 class KWINEFFECTS_EXPORT WindowPaintData : public PaintData
 {
 public:
     explicit WindowPaintData(EffectWindow* w);
     explicit WindowPaintData(EffectWindow* w, const QMatrix4x4 &screenProjectionMatrix);
     WindowPaintData(const WindowPaintData &other);
     virtual ~WindowPaintData();
     /**
      * Scales the window by @p scale factor.
      * Multiplies all three components by the given factor.
      * @since 4.10
      **/
     WindowPaintData& operator*=(qreal scale);
     /**
      * Scales the window by @p scale factor.
      * Performs a component wise multiplication on x and y components.
      * @since 4.10
      **/
     WindowPaintData& operator*=(const QVector2D &scale);
     /**
      * Scales the window by @p scale factor.
      * Performs a component wise multiplication.
      * @since 4.10
      **/
     WindowPaintData& operator*=(const QVector3D &scale);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * @since 4.10
      **/
     WindowPaintData& operator+=(const QPointF &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     WindowPaintData& operator+=(const QPoint &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     WindowPaintData& operator+=(const QVector2D &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     WindowPaintData& operator+=(const QVector3D &translation);
     /**
      * Window opacity, in range 0 = transparent to 1 = fully opaque
      * @see setOpacity
      * @since 4.10
      */
     qreal opacity() const;
     /**
      * Sets the window opacity to the new @p opacity.
      * If you want to modify the existing opacity level consider using multiplyOpacity.
      * @param opacity The new opacity level
      * @since 4.10
      **/
     void setOpacity(qreal opacity);
     /**
      * Multiplies the current opacity with the @p factor.
      * @param factor Factor with which the opacity should be multiplied
      * @return New opacity level
      * @since 4.10
      **/
     qreal multiplyOpacity(qreal factor);
     /**
      * Saturation of the window, in range [0; 1]
      * 1 means that the window is unchanged, 0 means that it's completely
      *  unsaturated (greyscale). 0.5 would make the colors less intense,
      *  but not completely grey
      * Use EffectsHandler::saturationSupported() to find out whether saturation
      * is supported by the system, otherwise this value has no effect.
      * @return The current saturation
      * @see setSaturation()
      * @since 4.10
      **/
     qreal saturation() const;
     /**
      * Sets the window saturation level to @p saturation.
      * If you want to modify the existing saturation level consider using multiplySaturation.
      * @param saturation The new saturation level
      * @since 4.10
      **/
     void setSaturation(qreal saturation) const;
     /**
      * Multiplies the current saturation with @p factor.
      * @param factor with which the saturation should be multiplied
      * @return New saturation level
      * @since 4.10
      **/
     qreal multiplySaturation(qreal factor);
     /**
      * Brightness of the window, in range [0; 1]
      * 1 means that the window is unchanged, 0 means that it's completely
      * black. 0.5 would make it 50% darker than usual
      **/
     qreal brightness() const;
     /**
      * Sets the window brightness level to @p brightness.
      * If you want to modify the existing brightness level consider using multiplyBrightness.
      * @param brightness The new brightness level
      **/
     void setBrightness(qreal brightness);
     /**
      * Multiplies the current brightness level with @p factor.
      * @param factor with which the brightness should be multiplied.
      * @return New brightness level
      * @since 4.10
      **/
     qreal multiplyBrightness(qreal factor);
     /**
      * The screen number for which the painting should be done.
      * This affects color correction (different screens may need different
      * color correction lookup tables because they have different ICC profiles).
      * @return screen for which painting should be done
      */
     int screen() const;
     /**
      * @param screen New screen number
      * A value less than 0 will indicate that a default profile should be done.
      */
     void setScreen(int screen) const;
     /**
      * @brief Sets the cross fading @p factor to fade over with previously sized window.
      * If @c 1.0 only the current window is used, if @c 0.0 only the previous window is used.
      *
      * By default only the current window is used. This factor can only make any visual difference
      * if the previous window get referenced.
      *
      * @param factor The cross fade factor between @c 0.0 (previous window) and @c 1.0 (current window)
      * @see crossFadeProgress
      */
     void setCrossFadeProgress(qreal factor);
     /**
      * @see setCrossFadeProgress
      */
     qreal crossFadeProgress() const;
 
     /**
      * Sets the projection matrix that will be used when painting the window.
      *
      * The default projection matrix can be overridden by setting this matrix
      * to a non-identity matrix.
      */
     void setProjectionMatrix(const QMatrix4x4 &matrix);
 
     /**
      * Returns the current projection matrix.
      *
      * The default value for this matrix is the identity matrix.
      */
     QMatrix4x4 projectionMatrix() const;
 
     /**
      * Returns a reference to the projection matrix.
      */
     QMatrix4x4 &rprojectionMatrix();
 
     /**
      * Sets the model-view matrix that will be used when painting the window.
      *
      * The default model-view matrix can be overridden by setting this matrix
      * to a non-identity matrix.
      */
     void setModelViewMatrix(const QMatrix4x4 &matrix);
 
     /**
      * Returns the current model-view matrix.
      *
      * The default value for this matrix is the identity matrix.
      */
     QMatrix4x4 modelViewMatrix() const;
 
     /**
      * Returns a reference to the model-view matrix.
      */
     QMatrix4x4 &rmodelViewMatrix();
 
     /**
      * Returns The projection matrix as used by the current screen painting pass
      * including screen transformations.
      *
      * @since 5.6
      **/
     QMatrix4x4 screenProjectionMatrix() const;
 
     WindowQuadList quads;
 
     /**
      * Shader to be used for rendering, if any.
      */
     GLShader* shader;
 
 private:
     WindowPaintDataPrivate * const d;
 };
 
 class KWINEFFECTS_EXPORT ScreenPaintData : public PaintData
 {
 public:
     ScreenPaintData();
     ScreenPaintData(const QMatrix4x4 &projectionMatrix, const QRect &outputGeometry = QRect());
     ScreenPaintData(const ScreenPaintData &other);
     virtual ~ScreenPaintData();
     /**
      * Scales the screen by @p scale factor.
      * Multiplies all three components by the given factor.
      * @since 4.10
      **/
     ScreenPaintData& operator*=(qreal scale);
     /**
      * Scales the screen by @p scale factor.
      * Performs a component wise multiplication on x and y components.
      * @since 4.10
      **/
     ScreenPaintData& operator*=(const QVector2D &scale);
     /**
      * Scales the screen by @p scale factor.
      * Performs a component wise multiplication.
      * @since 4.10
      **/
     ScreenPaintData& operator*=(const QVector3D &scale);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * @since 4.10
      **/
     ScreenPaintData& operator+=(const QPointF &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     ScreenPaintData& operator+=(const QPoint &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     ScreenPaintData& operator+=(const QVector2D &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      **/
     ScreenPaintData& operator+=(const QVector3D &translation);
     ScreenPaintData& operator=(const ScreenPaintData &rhs);
 
     /**
      * The projection matrix used by the scene for the current rendering pass.
      * On non-OpenGL compositors it's set to Identity matrix.
      * @since 5.6
      **/
     QMatrix4x4 projectionMatrix() const;
 
     /**
      * The geometry of the currently rendered output.
      * Only set for per-output rendering (e.g. Wayland).
      *
      * This geometry can be used as a hint about the native window the OpenGL context
      * is bound. OpenGL calls need to be translated to this geometry.
      * @since 5.9
      **/
     QRect outputGeometry() const;
 private:
     class Private;
     QScopedPointer<Private> d;
 };
 
 class KWINEFFECTS_EXPORT ScreenPrePaintData
 {
 public:
     int mask;
     QRegion paint;
 };
 
 /**
  * @short Helper class for restricting painting area only to allowed area.
  *
  * This helper class helps specifying areas that should be painted, clipping
  * out the rest. The simplest usage is creating an object on the stack
  * and giving it the area that is allowed to be painted to. When the object
  * is destroyed, the restriction will be removed.
  * Note that all painting code must use paintArea() to actually perform the clipping.
  */
 class KWINEFFECTS_EXPORT PaintClipper
 {
 public:
     /**
      * Calls push().
      */
     explicit PaintClipper(const QRegion& allowed_area);
     /**
      * Calls pop().
      */
     ~PaintClipper();
     /**
      * Allows painting only in the given area. When areas have been already
      * specified, painting is allowed only in the intersection of all areas.
      */
     static void push(const QRegion& allowed_area);
     /**
      * Removes the given area. It must match the top item in the stack.
      */
     static void pop(const QRegion& allowed_area);
     /**
      * Returns true if any clipping should be performed.
      */
     static bool clip();
     /**
      * If clip() returns true, this function gives the resulting area in which
      * painting is allowed. It is usually simpler to use the helper Iterator class.
      */
     static QRegion paintArea();
     /**
      * Helper class to perform the clipped painting. The usage is:
      * @code
      * for ( PaintClipper::Iterator iterator;
      *      !iterator.isDone();
      *      iterator.next())
      *     { // do the painting, possibly use iterator.boundingRect()
      *     }
      * @endcode
      */
     class KWINEFFECTS_EXPORT Iterator
     {
     public:
         Iterator();
         ~Iterator();
         bool isDone();
         void next();
         QRect boundingRect() const;
     private:
         struct Data;
         Data* data;
     };
 private:
     QRegion area;
     static QStack< QRegion >* areas;
 };
 
 /**
  * @internal
  */
 template <typename T>
 class KWINEFFECTS_EXPORT Motion
 {
 public:
     /**
      * Creates a new motion object. "Strength" is the amount of
      * acceleration that is applied to the object when the target
      * changes and "smoothness" relates to how fast the object
      * can change its direction and speed.
      */
     explicit Motion(T initial, double strength, double smoothness);
     /**
      * Creates an exact copy of another motion object, including
      * position, target and velocity.
      */
     Motion(const Motion<T> &other);
     ~Motion();
 
     inline T value() const {
         return m_value;
     }
     inline void setValue(const T value) {
         m_value = value;
     }
     inline T target() const {
         return m_target;
     }
     inline void setTarget(const T target) {
         m_start = m_value;
         m_target = target;
     }
     inline T velocity() const {
         return m_velocity;
     }
     inline void setVelocity(const T velocity) {
         m_velocity = velocity;
     }
 
     inline double strength() const {
         return m_strength;
     }
     inline void setStrength(const double strength) {
         m_strength = strength;
     }
     inline double smoothness() const {
         return m_smoothness;
     }
     inline void setSmoothness(const double smoothness) {
         m_smoothness = smoothness;
     }
     inline T startValue() {
         return m_start;
     }
 
     /**
      * The distance between the current position and the target.
      */
     inline T distance() const {
         return m_target - m_value;
     }
 
     /**
      * Calculates the new position if not at the target. Called
      * once per frame only.
      */
     void calculate(const int msec);
     /**
      * Place the object on top of the target immediately,
      * bypassing all movement calculation.
      */
     void finish();
 
 private:
     T m_value;
     T m_start;
     T m_target;
     T m_velocity;
     double m_strength;
     double m_smoothness;
 };
 
 /**
  * @short A single 1D motion dynamics object.
  *
  * This class represents a single object that can be moved around a
  * 1D space. Although it can be used directly by itself it is
  * recommended to use a motion manager instead.
  */
 class KWINEFFECTS_EXPORT Motion1D : public Motion<double>
 {
 public:
     explicit Motion1D(double initial = 0.0, double strength = 0.08, double smoothness = 4.0);
     Motion1D(const Motion1D &other);
     ~Motion1D();
 };
 
 /**
  * @short A single 2D motion dynamics object.
  *
  * This class represents a single object that can be moved around a
  * 2D space. Although it can be used directly by itself it is
  * recommended to use a motion manager instead.
  */
 class KWINEFFECTS_EXPORT Motion2D : public Motion<QPointF>
 {
 public:
     explicit Motion2D(QPointF initial = QPointF(), double strength = 0.08, double smoothness = 4.0);
     Motion2D(const Motion2D &other);
     ~Motion2D();
 };
 
 /**
  * @short Helper class for motion dynamics in KWin effects.
  *
  * This motion manager class is intended to help KWin effect authors
  * move windows across the screen smoothly and naturally. Once
  * windows are registered by the manager the effect can issue move
  * commands with the moveWindow() methods. The position of any
  * managed window can be determined in realtime by the
  * transformedGeometry() method. As the manager knows if any windows
  * are moving at any given time it can also be used as a notifier as
  * to see whether the effect is active or not.
  */
 class KWINEFFECTS_EXPORT WindowMotionManager
 {
 public:
     /**
      * Creates a new window manager object.
      */
     explicit WindowMotionManager(bool useGlobalAnimationModifier = true);
     ~WindowMotionManager();
 
     /**
      * Register a window for managing.
      */
     void manage(EffectWindow *w);
     /**
      * Register a list of windows for managing.
      */
     inline void manage(EffectWindowList list) {
         for (int i = 0; i < list.size(); i++)
             manage(list.at(i));
     }
     /**
      * Deregister a window. All transformations applied to the
      * window will be permanently removed and cannot be recovered.
      */
     void unmanage(EffectWindow *w);
     /**
      * Deregister all windows, returning the manager to its
      * originally initiated state.
      */
     void unmanageAll();
     /**
      * Determine the new positions for windows that have not
      * reached their target. Called once per frame, usually in
      * prePaintScreen(). Remember to set the
      * Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS flag.
      */
     void calculate(int time);
     /**
      * Modify a registered window's paint data to make it appear
      * at its real location on the screen. Usually called in
      * paintWindow(). Remember to flag the window as having been
      * transformed in prePaintWindow() by calling
      * WindowPrePaintData::setTransformed()
      */
     void apply(EffectWindow *w, WindowPaintData &data);
     /**
      * Set all motion targets and values back to where the
      * windows were before transformations. The same as
      * unmanaging then remanaging all windows.
      */
     void reset();
     /**
      * Resets the motion target and current value of a single
      * window.
      */
     void reset(EffectWindow *w);
 
     /**
      * Ask the manager to move the window to the target position
      * with the specified scale. If `yScale` is not provided or
      * set to 0.0, `scale` will be used as the scale in the
      * vertical direction as well as in the horizontal direction.
      */
     void moveWindow(EffectWindow *w, QPoint target, double scale = 1.0, double yScale = 0.0);
     /**
      * This is an overloaded method, provided for convenience.
      *
      * Ask the manager to move the window to the target rectangle.
      * Automatically determines scale.
      */
     inline void moveWindow(EffectWindow *w, QRect target) {
         // TODO: Scale might be slightly different in the comparison due to rounding
         moveWindow(w, target.topLeft(),
                    target.width() / double(w->width()), target.height() / double(w->height()));
     }
 
     /**
      * Retrieve the current tranformed geometry of a registered
      * window.
      */
     QRectF transformedGeometry(EffectWindow *w) const;
     /**
      * Sets the current transformed geometry of a registered window to the given geometry.
      * @see transformedGeometry
      * @since 4.5
      */
     void setTransformedGeometry(EffectWindow *w, const QRectF &geometry);
     /**
      * Retrieve the current target geometry of a registered
      * window.
      */
     QRectF targetGeometry(EffectWindow *w) const;
     /**
      * Return the window that has its transformed geometry under
      * the specified point. It is recommended to use the stacking
      * order as it's what the user sees, but it is slightly
      * slower to process.
      */
     EffectWindow* windowAtPoint(QPoint point, bool useStackingOrder = true) const;
 
     /**
      * Return a list of all currently registered windows.
      */
     inline EffectWindowList managedWindows() const {
         return m_managedWindows.keys();
     }
     /**
      * Returns whether or not a specified window is being managed
      * by this manager object.
      */
     inline bool isManaging(EffectWindow *w) const {
         return m_managedWindows.contains(w);
     }
     /**
      * Returns whether or not this manager object is actually
      * managing any windows or not.
      */
     inline bool managingWindows() const {
         return !m_managedWindows.empty();
     }
     /**
      * Returns whether all windows have reached their targets yet
      * or not. Can be used to see if an effect should be
      * processed and displayed or not.
      */
     inline bool areWindowsMoving() const {
         return !m_movingWindowsSet.isEmpty();
     }
     /**
      * Returns whether a window has reached its targets yet
      * or not.
      */
     inline bool isWindowMoving(EffectWindow *w) const {
         return m_movingWindowsSet.contains(w);
     }
 
 private:
     bool m_useGlobalAnimationModifier;
     struct WindowMotion {
         // TODO: Rotation, etc?
         Motion2D translation; // Absolute position
         Motion2D scale; // xScale and yScale
     };
     QHash<EffectWindow*, WindowMotion> m_managedWindows;
     QSet<EffectWindow*> m_movingWindowsSet;
 };
 
 /**
  * @short Helper class for displaying text and icons in frames.
  *
  * Paints text and/or and icon with an optional frame around them. The
  * available frames includes one that follows the default Plasma theme and
  * another that doesn't.
  * It is recommended to use this class whenever displaying text.
  */
 class KWINEFFECTS_EXPORT EffectFrame
 {
 public:
     EffectFrame();
     virtual ~EffectFrame();
 
     /**
      * Delete any existing textures to free up graphics memory. They will
      * be automatically recreated the next time they are required.
      */
     virtual void free() = 0;
 
     /**
      * Render the frame.
      */
     virtual void render(QRegion region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) = 0;
 
     virtual void setPosition(const QPoint& point) = 0;
     /**
      * Set the text alignment for static frames and the position alignment
      * for non-static.
      */
     virtual void setAlignment(Qt::Alignment alignment) = 0;
     virtual Qt::Alignment alignment() const = 0;
     virtual void setGeometry(const QRect& geometry, bool force = false) = 0;
     virtual const QRect& geometry() const = 0;
 
     virtual void setText(const QString& text) = 0;
     virtual const QString& text() const = 0;
     virtual void setFont(const QFont& font) = 0;
     virtual const QFont& font() const = 0;
     /**
      * Set the icon that will appear on the left-hand size of the frame.
      */
     virtual void setIcon(const QIcon& icon) = 0;
     virtual const QIcon& icon() const = 0;
     virtual void setIconSize(const QSize& size) = 0;
     virtual const QSize& iconSize() const = 0;
 
     /**
      * Sets the geometry of a selection.
      * To remove the selection set a null rect.
      * @param selection The geometry of the selection in screen coordinates.
      **/
     virtual void setSelection(const QRect& selection) = 0;
 
     /**
      * @param shader The GLShader for rendering.
      **/
     virtual void setShader(GLShader* shader) = 0;
     /**
      * @returns The GLShader used for rendering or null if none.
      **/
     virtual GLShader* shader() const = 0;
 
     /**
      * @returns The style of this EffectFrame.
      **/
     virtual EffectFrameStyle style() const = 0;
 
     /**
      * If @p enable is @c true cross fading between icons and text is enabled
      * By default disabled. Use setCrossFadeProgress to cross fade.
      * Cross Fading is currently only available if OpenGL is used.
      * @param enable @c true enables cross fading, @c false disables it again
      * @see isCrossFade
      * @see setCrossFadeProgress
      * @since 4.6
      **/
     void enableCrossFade(bool enable);
     /**
      * @returns @c true if cross fading is enabled, @c false otherwise
      * @see enableCrossFade
      * @since 4.6
      **/
     bool isCrossFade() const;
     /**
      * Sets the current progress for cross fading the last used icon/text
      * with current icon/text to @p progress.
      * A value of 0.0 means completely old icon/text, a value of 1.0 means
      * completely current icon/text.
      * Default value is 1.0. You have to enable cross fade before using it.
      * Cross Fading is currently only available if OpenGL is used.
      * @see enableCrossFade
      * @see isCrossFade
      * @see crossFadeProgress
      * @since 4.6
      **/
     void setCrossFadeProgress(qreal progress);
     /**
      * @returns The current progress for cross fading
      * @see setCrossFadeProgress
      * @see enableCrossFade
      * @see isCrossFade
      * @since 4.6
      **/
     qreal crossFadeProgress() const;
 
     /**
      * Returns The projection matrix as used by the current screen painting pass
      * including screen transformations.
      *
      * This matrix is only valid during a rendering pass started by render.
      *
      * @since 5.6
      * @see render
      * @see EffectsHandler::paintEffectFrame
      * @see Effect::paintEffectFrame
      **/
     QMatrix4x4 screenProjectionMatrix() const;
 
 protected:
     void setScreenProjectionMatrix(const QMatrix4x4 &projection);
 
 private:
     EffectFramePrivate* const d;
 };
 
 /**
  * Pointer to the global EffectsHandler object.
  **/
 extern KWINEFFECTS_EXPORT EffectsHandler* effects;
 
 /***************************************************************
  WindowVertex
 ***************************************************************/
 
 inline
 WindowVertex::WindowVertex()
     : px(0), py(0), tx(0), ty(0)
 {
 }
 
 inline
 WindowVertex::WindowVertex(double _x, double _y, double _tx, double _ty)
     : px(_x), py(_y), ox(_x), oy(_y), tx(_tx), ty(_ty)
 {
 }
 
 inline
 void WindowVertex::move(double x, double y)
 {
     px = x;
     py = y;
 }
 
 inline
 void WindowVertex::setX(double x)
 {
     px = x;
 }
 
 inline
 void WindowVertex::setY(double y)
 {
     py = y;
 }
 
 /***************************************************************
  WindowQuad
 ***************************************************************/
 
 inline
 WindowQuad::WindowQuad(WindowQuadType t, int id)
     : quadType(t)
     , uvSwapped(false)
     , quadID(id)
 {
 }
 
 inline
 WindowVertex& WindowQuad::operator[](int index)
 {
     assert(index >= 0 && index < 4);
     return verts[ index ];
 }
 
 inline
 const WindowVertex& WindowQuad::operator[](int index) const
 {
     assert(index >= 0 && index < 4);
     return verts[ index ];
 }
 
 inline
 WindowQuadType WindowQuad::type() const
 {
     assert(quadType != WindowQuadError);
     return quadType;
 }
 
 inline
 int WindowQuad::id() const
 {
     return quadID;
 }
 
 inline
 bool WindowQuad::decoration() const
 {
     assert(quadType != WindowQuadError);
     return quadType == WindowQuadDecoration;
 }
 
 inline
 bool WindowQuad::effect() const
 {
     assert(quadType != WindowQuadError);
     return quadType >= EFFECT_QUAD_TYPE_START;
 }
 
 inline
 bool WindowQuad::isTransformed() const
 {
     return !(verts[ 0 ].px == verts[ 0 ].ox && verts[ 0 ].py == verts[ 0 ].oy
              && verts[ 1 ].px == verts[ 1 ].ox && verts[ 1 ].py == verts[ 1 ].oy
              && verts[ 2 ].px == verts[ 2 ].ox && verts[ 2 ].py == verts[ 2 ].oy
              && verts[ 3 ].px == verts[ 3 ].ox && verts[ 3 ].py == verts[ 3 ].oy);
 }
 
 inline
 double WindowQuad::left() const
 {
     return qMin(verts[ 0 ].px, qMin(verts[ 1 ].px, qMin(verts[ 2 ].px, verts[ 3 ].px)));
 }
 
 inline
 double WindowQuad::right() const
 {
     return qMax(verts[ 0 ].px, qMax(verts[ 1 ].px, qMax(verts[ 2 ].px, verts[ 3 ].px)));
 }
 
 inline
 double WindowQuad::top() const
 {
     return qMin(verts[ 0 ].py, qMin(verts[ 1 ].py, qMin(verts[ 2 ].py, verts[ 3 ].py)));
 }
 
 inline
 double WindowQuad::bottom() const
 {
     return qMax(verts[ 0 ].py, qMax(verts[ 1 ].py, qMax(verts[ 2 ].py, verts[ 3 ].py)));
 }
 
 inline
 double WindowQuad::originalLeft() const
 {
     return verts[ 0 ].ox;
 }
 
 inline
 double WindowQuad::originalRight() const
 {
     return verts[ 2 ].ox;
 }
 
 inline
 double WindowQuad::originalTop() const
 {
     return verts[ 0 ].oy;
 }
 
 inline
 double WindowQuad::originalBottom() const
 {
     return verts[ 2 ].oy;
 }
 
 /***************************************************************
  Motion
 ***************************************************************/
 
 template <typename T>
 Motion<T>::Motion(T initial, double strength, double smoothness)
     :   m_value(initial)
     ,   m_start(initial)
     ,   m_target(initial)
     ,   m_velocity()
     ,   m_strength(strength)
     ,   m_smoothness(smoothness)
 {
 }
 
 template <typename T>
 Motion<T>::Motion(const Motion &other)
     :   m_value(other.value())
     ,   m_start(other.target())
     ,   m_target(other.target())
     ,   m_velocity(other.velocity())
     ,   m_strength(other.strength())
     ,   m_smoothness(other.smoothness())
 {
 }
 
 template <typename T>
 Motion<T>::~Motion()
 {
 }
 
 template <typename T>
 void Motion<T>::calculate(const int msec)
 {
     if (m_value == m_target && m_velocity == T())   // At target and not moving
         return;
 
     // Poor man's time independent calculation
     int steps = qMax(1, msec / 5);
     for (int i = 0; i < steps; i++) {
         T diff = m_target - m_value;
         T strength = diff * m_strength;
         m_velocity = (m_smoothness * m_velocity + strength) / (m_smoothness + 1.0);
         m_value += m_velocity;
     }
 }
 
 template <typename T>
 void Motion<T>::finish()
 {
     m_value = m_target;
     m_velocity = T();
 }
 
 /***************************************************************
  Effect
 ***************************************************************/
 template <typename T>
 int Effect::animationTime(int defaultDuration)
 {
     return animationTime(T::duration() != 0 ? T::duration() : defaultDuration);
 }
 
 } // namespace
 Q_DECLARE_METATYPE(KWin::EffectWindow*)
 Q_DECLARE_METATYPE(QList<KWin::EffectWindow*>)
 
 /** @} */
 
 #endif // KWINEFFECTS_H
diff --git a/platform.cpp b/platform.cpp
index de4325126..57f24c80f 100644
--- a/platform.cpp
+++ b/platform.cpp
@@ -1,380 +1,389 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "platform.h"
 #include <config-kwin.h>
 #include "abstract_egl_backend.h"
 #include "composite.h"
 #include "cursor.h"
 #include "input.h"
 #include "pointer_input.h"
 #include "scene_opengl.h"
 #include "screenedge.h"
 #include "wayland_server.h"
 
 namespace KWin
 {
 
 Platform::Platform(QObject *parent)
     : QObject(parent)
     , m_eglDisplay(EGL_NO_DISPLAY)
 {
 }
 
 Platform::~Platform()
 {
     if (m_eglDisplay != EGL_NO_DISPLAY) {
         eglTerminate(m_eglDisplay);
     }
 }
 
 QImage Platform::softwareCursor() const
 {
     return input()->pointer()->cursorImage();
 }
 
 QPoint Platform::softwareCursorHotspot() const
 {
     return input()->pointer()->cursorHotSpot();
 }
 
 PlatformCursorImage Platform::cursorImage() const
 {
     return PlatformCursorImage(softwareCursor(), softwareCursorHotspot());
 }
 
 void Platform::hideCursor()
 {
     m_hideCursorCounter++;
     if (m_hideCursorCounter == 1) {
         doHideCursor();
     }
 }
 
 void Platform::doHideCursor()
 {
 }
 
 void Platform::showCursor()
 {
     m_hideCursorCounter--;
     if (m_hideCursorCounter == 0) {
         doShowCursor();
     }
 }
 
 void Platform::doShowCursor()
 {
 }
 
 Screens *Platform::createScreens(QObject *parent)
 {
     Q_UNUSED(parent)
     return nullptr;
 }
 
 OpenGLBackend *Platform::createOpenGLBackend()
 {
     return nullptr;
 }
 
 QPainterBackend *Platform::createQPainterBackend()
 {
     return nullptr;
 }
 
 Edge *Platform::createScreenEdge(ScreenEdges *edges)
 {
     return new Edge(edges);
 }
 
 void Platform::createPlatformCursor(QObject *parent)
 {
     new InputRedirectionCursor(parent);
 }
 
 void Platform::configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config)
 {
     Q_UNUSED(config)
     qCWarning(KWIN_CORE) << "This backend does not support configuration changes.";
 }
 
 void Platform::setSoftWareCursor(bool set)
 {
     if (m_softWareCursor == set) {
         return;
     }
     m_softWareCursor = set;
     if (m_softWareCursor) {
         connect(Cursor::self(), &Cursor::posChanged, this, &Platform::triggerCursorRepaint);
         connect(this, &Platform::cursorChanged, this, &Platform::triggerCursorRepaint);
     } else {
         disconnect(Cursor::self(), &Cursor::posChanged, this, &Platform::triggerCursorRepaint);
         disconnect(this, &Platform::cursorChanged, this, &Platform::triggerCursorRepaint);
     }
 }
 
 void Platform::triggerCursorRepaint()
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(m_cursor.lastRenderedGeometry);
     Compositor::self()->addRepaint(QRect(Cursor::pos() - softwareCursorHotspot(), softwareCursor().size()));
 }
 
 void Platform::markCursorAsRendered()
 {
     if (m_softWareCursor) {
         m_cursor.lastRenderedGeometry = QRect(Cursor::pos() - softwareCursorHotspot(), softwareCursor().size());
     }
     if (input()->pointer()) {
         input()->pointer()->markCursorAsRendered();
     }
 }
 
 void Platform::keyboardKeyPressed(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyPressed, time);
 }
 
 void Platform::keyboardKeyReleased(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyReleased, time);
 }
 
 void Platform::keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void Platform::keymapChange(int fd, uint32_t size)
 {
     if (!input()) {
         return;
     }
     input()->processKeymapChange(fd, size);
 }
 
 void Platform::pointerAxisHorizontal(qreal delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisHorizontal, delta, time);
 }
 
 void Platform::pointerAxisVertical(qreal delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisVertical, delta, time);
 }
 
 void Platform::pointerButtonPressed(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonPressed, time);
 }
 
 void Platform::pointerButtonReleased(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonReleased, time);
 }
 
 void Platform::pointerMotion(const QPointF &position, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerMotion(position, time);
 }
 
 void Platform::touchCancel()
 {
     if (!input()) {
         return;
     }
     input()->cancelTouch();
 }
 
 void Platform::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchDown(id, pos, time);
 }
 
 void Platform::touchFrame()
 {
     if (!input()) {
         return;
     }
     input()->touchFrame();
 }
 
 void Platform::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchMotion(id, pos, time);
 }
 
 void Platform::touchUp(qint32 id, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchUp(id, time);
 }
 
 void Platform::repaint(const QRect &rect)
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(rect);
 }
 
 void Platform::setReady(bool ready)
 {
     if (m_ready == ready) {
         return;
     }
     m_ready = ready;
     emit readyChanged(m_ready);
 }
 
 void Platform::warpPointer(const QPointF &globalPos)
 {
     Q_UNUSED(globalPos)
 }
 
 bool Platform::supportsQpaContext() const
 {
     if (Compositor *c = Compositor::self()) {
         if (SceneOpenGL *s = dynamic_cast<SceneOpenGL*>(c->scene())) {
             return s->backend()->hasExtension(QByteArrayLiteral("EGL_KHR_surfaceless_context"));
         }
     }
     return false;
 }
 
 EGLDisplay KWin::Platform::sceneEglDisplay() const
 {
     return m_eglDisplay;
 }
 
 void Platform::setSceneEglDisplay(EGLDisplay display)
 {
     m_eglDisplay = display;
 }
 
 EGLContext Platform::sceneEglContext() const
 {
     if (Compositor *c = Compositor::self()) {
         if (SceneOpenGL *s = dynamic_cast<SceneOpenGL*>(c->scene())) {
             return static_cast<AbstractEglBackend*>(s->backend())->context();
         }
     }
     return EGL_NO_CONTEXT;
 }
 
 EGLSurface Platform::sceneEglSurface() const
 {
     if (Compositor *c = Compositor::self()) {
         if (SceneOpenGL *s = dynamic_cast<SceneOpenGL*>(c->scene())) {
             return static_cast<AbstractEglBackend*>(s->backend())->surface();
         }
     }
     return EGL_NO_SURFACE;
 }
 
 EGLConfig Platform::sceneEglConfig() const
 {
     if (Compositor *c = Compositor::self()) {
         if (SceneOpenGL *s = dynamic_cast<SceneOpenGL*>(c->scene())) {
             return static_cast<AbstractEglBackend*>(s->backend())->config();
         }
     }
     return nullptr;
 }
 
 QSize Platform::screenSize() const
 {
     return QSize();
 }
 
 QVector<QRect> Platform::screenGeometries() const
 {
     return QVector<QRect>({QRect(QPoint(0, 0), screenSize())});
 }
 
 bool Platform::requiresCompositing() const
 {
     return true;
 }
 
 bool Platform::compositingPossible() const
 {
     return true;
 }
 
 QString Platform::compositingNotPossibleReason() const
 {
     return QString();
 }
 
 bool Platform::openGLCompositingIsBroken() const
 {
     return false;
 }
 
 void Platform::createOpenGLSafePoint(OpenGLSafePoint safePoint)
 {
     Q_UNUSED(safePoint)
 }
 
 void Platform::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!input()) {
         callback(nullptr);
         return;
     }
     input()->startInteractiveWindowSelection(callback, cursorName);
 }
 
+void Platform::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
+{
+    if (!input()) {
+        callback(QPoint(-1, -1));
+        return;
+    }
+    input()->startInteractivePositionSelection(callback);
+}
+
 }
diff --git a/platform.h b/platform.h
index 55b034c33..87ba3658d 100644
--- a/platform.h
+++ b/platform.h
@@ -1,345 +1,361 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_PLATFORM_H
 #define KWIN_PLATFORM_H
 #include <kwin_export.h>
 #include <kwinglobals.h>
 #include <epoxy/egl.h>
 #include <fixx11h.h>
 #include <QImage>
 #include <QObject>
 
 #include <functional>
 
 namespace KWayland {
     namespace Server {
         class OutputConfigurationInterface;
     }
 }
 
 namespace KWin
 {
 
 class Edge;
 class OpenGLBackend;
 class QPainterBackend;
 class Screens;
 class ScreenEdges;
 class Toplevel;
 class WaylandCursorTheme;
 
 class KWIN_EXPORT Platform : public QObject
 {
     Q_OBJECT
 public:
     virtual ~Platform();
 
     virtual void init() = 0;
     virtual Screens *createScreens(QObject *parent = nullptr);
     virtual OpenGLBackend *createOpenGLBackend();
     virtual QPainterBackend *createQPainterBackend();
     /**
      * Allows the platform to create a platform specific screen edge.
      * The default implementation creates a Edge.
      **/
     virtual Edge *createScreenEdge(ScreenEdges *parent);
     /**
      * Allows the platform to create a platform specific Cursor.
      * The default implementation creates an InputRedirectionCursor.
      **/
     virtual void createPlatformCursor(QObject *parent = nullptr);
     virtual void warpPointer(const QPointF &globalPos);
     /**
      * Whether our Compositing EGL display allows a surface less context
      * so that a sharing context could be created.
      **/
     virtual bool supportsQpaContext() const;
     /**
      * The EGLDisplay used by the compositing scene.
      **/
     EGLDisplay sceneEglDisplay() const;
     void setSceneEglDisplay(EGLDisplay display);
     /**
      * The EGLContext used by the compositing scene.
      **/
     virtual EGLContext sceneEglContext() const;
     /**
      * The first (in case of multiple) EGLSurface used by the compositing scene.
      **/
     EGLSurface sceneEglSurface() const;
 
     /**
      * The EglConfig used by the compositing scene.
      **/
     EGLConfig sceneEglConfig() const;
 
     /**
      * Implementing subclasses should provide a size in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns an invalid size.
      **/
     virtual QSize screenSize() const;
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns one QRect positioned at 0/0 with screenSize() as size.
      **/
     virtual QVector<QRect> screenGeometries() const;
     /**
      * Implement this method to receive configuration change requests through KWayland's
      * OutputManagement interface.
      *
      * Base implementation warns that the current backend does not implement this
      * functionality.
      */
     virtual void configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config);
 
     /**
      * Whether the Platform requires compositing for rendering.
      * Default implementation returns @c true. If the implementing Platform allows to be used
      * without compositing (e.g. rendering is done by the windowing system), re-implement this method.
      **/
     virtual bool requiresCompositing() const;
     /**
      * Whether Compositing is possible in the Platform.
      * Returning @c false in this method makes only sense if @link{requiresCompositing} returns @c false.
      *
      * The default implementation returns @c true.
      * @see requiresCompositing
      **/
     virtual bool compositingPossible() const;
     /**
      * Returns a user facing text explaining why compositing is not possible in case
      * @link{compositingPossible} returns @c false.
      *
      * The default implementation returns an empty string.
      * @see compositingPossible
      **/
     virtual QString compositingNotPossibleReason() const;
     /**
      * Whether OpenGL compositing is broken.
      * The Platform can implement this method if it is able to detect whether OpenGL compositing
      * broke (e.g. triggered a crash in a previous run).
      *
      * Default implementation returns @c false.
      * @see createOpenGLSafePoint
      **/
     virtual bool openGLCompositingIsBroken() const;
     enum class OpenGLSafePoint {
         PreInit,
         PostInit,
         PreFrame,
         PostFrame,
         PostLastGuardedFrame
     };
     /**
      * This method is invoked before and after creating the OpenGL rendering Scene.
      * An implementing Platform can use it to detect crashes triggered by the OpenGL implementation.
      * This can be used for @link{openGLCompositingIsBroken}.
      *
      * The default implementation does nothing.
      * @see openGLCompositingIsBroken.
      **/
     virtual void createOpenGLSafePoint(OpenGLSafePoint safePoint);
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected Toplevel as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor unless
      * @p cursorName is provided. The argument @p cursorName is a QByteArray instead of Qt::CursorShape
      * to support the "pirate" cursor for kill window which is not wrapped by Qt::CursorShape.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @param cursorName The optional name of the cursor shape to use, default is crosshair
      **/
     virtual void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName = QByteArray());
 
+    /**
+     * Starts an interactive position selection process.
+     *
+     * Once the user selected a position on the screen the @p callback is invoked with
+     * the selected point as argument. In case the user cancels the interactive position selection
+     * or selecting a position is currently not possible (e.g. screen locked) the @p callback
+     * is invoked with a point at @c -1 as x and y argument.
+     *
+     * During the interactive window selection the cursor is turned into a crosshair cursor.
+     *
+     * The default implementation forwards to InputRedirection.
+     *
+     * @param callback The function to invoke once the interactive position selection ends
+     **/
+    virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
+
     bool usesSoftwareCursor() const {
         return m_softWareCursor;
     }
     QImage softwareCursor() const;
     QPoint softwareCursorHotspot() const;
     void markCursorAsRendered();
 
     /**
      * Returns a PlatformCursorImage. By default this is created by softwareCursor and
      * softwareCursorHotspot. An implementing subclass can use this to provide a better
      * suited PlatformCursorImage.
      *
      * @see softwareCursor
      * @see softwareCursorHotspot
      * @since 5.9
      **/
     virtual PlatformCursorImage cursorImage() const;
 
     /**
      * The Platform cursor image should be hidden.
      * @see showCursor
      * @see doHideCursor
      * @see isCursorHidden
      * @since 5.9
      **/
     void hideCursor();
 
     /**
      * The Platform cursor image should be shown again.
      * @see hideCursor
      * @see doShowCursor
      * @see isCursorHidden
      * @since 5.9
      **/
     void showCursor();
 
     /**
      * Whether the cursor is currently hidden.
      * @see showCursor
      * @see hideCursor
      * @since 5.9
      **/
     bool isCursorHidden() const {
         return m_hideCursorCounter > 0;
     }
 
     bool handlesOutputs() const {
         return m_handlesOutputs;
     }
     bool isReady() const {
         return m_ready;
     }
     void setInitialWindowSize(const QSize &size) {
         m_initialWindowSize = size;
     }
     void setDeviceIdentifier(const QByteArray &identifier) {
         m_deviceIdentifier = identifier;
     }
     bool supportsPointerWarping() const {
         return m_pointerWarping;
     }
     bool areOutputsEnabled() const {
         return m_outputsEnabled;
     }
     void setOutputsEnabled(bool enabled) {
         m_outputsEnabled = enabled;
     }
     int initialOutputCount() const {
         return m_initialOutputCount;
     }
     void setInitialOutputCount(int count) {
         m_initialOutputCount = count;
     }
 
 public Q_SLOTS:
     void pointerMotion(const QPointF &position, quint32 time);
     void pointerButtonPressed(quint32 button, quint32 time);
     void pointerButtonReleased(quint32 button, quint32 time);
     void pointerAxisHorizontal(qreal delta, quint32 time);
     void pointerAxisVertical(qreal delta, quint32 time);
     void keyboardKeyPressed(quint32 key, quint32 time);
     void keyboardKeyReleased(quint32 key, quint32 time);
     void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     void keymapChange(int fd, uint32_t size);
     void touchDown(qint32 id, const QPointF &pos, quint32 time);
     void touchUp(qint32 id, quint32 time);
     void touchMotion(qint32 id, const QPointF &pos, quint32 time);
     void touchCancel();
     void touchFrame();
 
 Q_SIGNALS:
     void screensQueried();
     void initFailed();
     void cursorChanged();
     void readyChanged(bool);
     /**
      * Emitted by backends using a one screen (nested window) approach and when the size of that changes.
      **/
     void screenSizeChanged();
 
 protected:
     explicit Platform(QObject *parent = nullptr);
     void setSoftWareCursor(bool set);
     void handleOutputs() {
         m_handlesOutputs = true;
     }
     void repaint(const QRect &rect);
     void setReady(bool ready);
     QSize initialWindowSize() const {
         return m_initialWindowSize;
     }
     QByteArray deviceIdentifier() const {
         return m_deviceIdentifier;
     }
     void setSupportsPointerWarping(bool set) {
         m_pointerWarping = set;
     }
 
     /**
      * Actual platform specific way to hide the cursor.
      * Sub-classes need to implement if they support hiding the cursor.
      *
      * This method is invoked by hideCursor if the cursor needs to be hidden.
      * The default implementation does nothing.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      **/
     virtual void doHideCursor();
     /**
      * Actual platform specific way to show the cursor.
      * Sub-classes need to implement if they support showing the cursor.
      *
      * This method is invoked by showCursor if the cursor needs to be shown again.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      **/
     virtual void doShowCursor();
 
 private:
     void triggerCursorRepaint();
     bool m_softWareCursor = false;
     struct {
         QRect lastRenderedGeometry;
     } m_cursor;
     bool m_handlesOutputs = false;
     bool m_ready = false;
     QSize m_initialWindowSize;
     QByteArray m_deviceIdentifier;
     bool m_pointerWarping = false;
     bool m_outputsEnabled = true;
     int m_initialOutputCount = 1;
     EGLDisplay m_eglDisplay;
     int m_hideCursorCounter = 0;
 };
 
 }
 
 Q_DECLARE_INTERFACE(KWin::Platform, "org.kde.kwin.Platform")
 
 #endif