diff --git a/input.cpp b/input.cpp
index d5a0c5573..ad432624e 100644
--- a/input.cpp
+++ b/input.cpp
@@ -1,1995 +1,1995 @@
 /********************************************************************
  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 "input_event_spy.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 PointerConstraintsFilter : public InputEventFilter {
 public:
     explicit PointerConstraintsFilter()
         : InputEventFilter()
         , m_timer(new QTimer)
     {
         QObject::connect(m_timer.data(), &QTimer::timeout,
             [this] {
                 input()->pointer()->breakPointerConstraints();
                 input()->pointer()->blockPointerConstraints();
                 // TODO: show notification
                 waylandServer()->seat()->keyReleased(m_keyCode);
                 cancel();
             }
         );
     }
 
     bool keyEvent(QKeyEvent *event) override {
         if (isActive()) {
             if (event->type() == QEvent::KeyPress) {
                 // is that another key that gets pressed?
                 if (!event->isAutoRepeat() && event->key() != Qt::Key_Escape) {
                     cancel();
                     return false;
                 }
                 if (event->isAutoRepeat() && event->key() == Qt::Key_Escape) {
                     // filter out
                     return true;
                 }
             } else {
                 cancel();
                 return false;
             }
         } else if (input()->pointer()->isConstrained()) {
             if (event->type() == QEvent::KeyPress &&
                     event->key() == Qt::Key_Escape &&
                     static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts() == Qt::KeyboardModifiers()) {
                 // TODO: don't hard code
                 m_timer->start(3000);
                 input()->keyboard()->update();
                 m_keyCode = event->nativeScanCode();
                 passToWaylandServer(event);
                 return true;
             }
         }
         return false;
     }
 
     void cancel() {
         if (!isActive()) {
             return;
         }
         m_timer->stop();
         input()->keyboard()->update();
     }
 
     bool isActive() const {
         return m_timer->isActive();
     }
 
 private:
     QScopedPointer<QTimer> m_timer;
     int m_keyCode = 0;
 };
 
 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() {
         if (m_callback) {
             m_callback(nullptr);
         }
         if (m_pointSelectionFallback) {
             m_pointSelectionFallback(QPoint(-1, -1));
         }
         deactivate();
     }
     void accept() {
         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(static_cast<KeyEvent*>(event)->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 (static_cast<KeyEvent*>(event)->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 (static_cast<MouseEvent*>(event)->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 (static_cast<WheelEvent*>(event)->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();
                 input()->pointer()->enablePointerConstraints();
             }
             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);
     qDeleteAll(m_spies);
 }
 
 void InputRedirection::installInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters << filter;
 }
 
-void InputRedirection::prepandInputEventFilter(InputEventFilter *filter)
+void InputRedirection::prependInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters.prepend(filter);
 }
 
 void InputRedirection::uninstallInputEventFilter(InputEventFilter *filter)
 {
     m_filters.removeOne(filter);
 }
 
 void InputRedirection::installInputEventSpy(InputEventSpy *spy)
 {
     m_spies << spy;
 }
 
 void InputRedirection::uninstallInputEventSpy(InputEventSpy *spy)
 {
     m_spies.removeOne(spy);
 }
 
 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_pointerConstraintsFilter = new PointerConstraintsFilter;
         installInputEventFilter(m_pointerConstraintsFilter);
         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();
 }
 
 Qt::KeyboardModifiers InputRedirection::modifiersRelevantForGlobalShortcuts() const
 {
     return m_keyboard->modifiersRelevantForGlobalShortcuts();
 }
 
 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;
 }
 
 bool InputRedirection::isBreakingPointerConstraints() const
 {
     return m_pointerConstraintsFilter ? m_pointerConstraintsFilter->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 575a2c6d1..fa554d9b2 100644
--- a/input.h
+++ b/input.h
@@ -1,422 +1,422 @@
 /********************************************************************
  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 InputEventSpy;
 class KeyboardInputRedirection;
 class PointerConstraintsFilter;
 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;
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() 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 prependInputEventFilter(InputEventFilter *filter);
     void uninstallInputEventFilter(InputEventFilter *filter);
 
     /**
      * Installs the @p spy for spying on events.
      **/
     void installInputEventSpy(InputEventSpy *spy);
 
     /**
      * Uninstalls the @p spy. This happens automatically when deleting an InputEventSpy.
      **/
     void uninstallInputEventSpy(InputEventSpy *spy);
 
     Toplevel *findToplevel(const QPoint &pos);
     GlobalShortcutsManager *shortcuts() const {
         return m_shortcuts;
     }
 
     /**
      * Sends an event through all InputFilters.
      * The method @p function is invoked on each input filter. Processing is stopped if
      * a filter returns @c true for @p function.
      *
      * The UnaryPredicate is defined like the UnaryPredicate of std::any_of.
      * The signature of the function should be equivalent to the following:
      * @code
      * bool function(const InputEventFilter *spy);
      * @endcode
      *
      * The intended usage is to std::bind the method to invoke on the filter with all arguments
      * bind.
      **/
     template <class UnaryPredicate>
     void processFilters(UnaryPredicate function) {
         std::any_of(m_filters.constBegin(), m_filters.constEnd(), function);
     }
 
     /**
      * Sends an event through all input event spies.
      * The @p function is invoked on each InputEventSpy.
      *
      * The UnaryFunction is defined like the UnaryFunction of std::for_each.
      * The signature of the function should be equivalent to the following:
      * @code
      * void function(const InputEventSpy *spy);
      * @endcode
      *
      * The intended usage is to std::bind the method to invoke on the spies with all arguments
      * bind.
      **/
     template <class UnaryFunction>
     void processSpies(UnaryFunction function) {
         std::for_each(m_spies.constBegin(), m_spies.constEnd(), function);
     }
 
     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;
 
     bool isBreakingPointerConstraints() 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;
     PointerConstraintsFilter *m_pointerConstraintsFilter = nullptr;
 
     QVector<InputEventFilter*> m_filters;
     QVector<InputEventSpy*> m_spies;
     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/plugins/platforms/drm/drm_backend.cpp b/plugins/platforms/drm/drm_backend.cpp
index 104cecf96..bb6b82169 100644
--- a/plugins/platforms/drm/drm_backend.cpp
+++ b/plugins/platforms/drm/drm_backend.cpp
@@ -1,723 +1,723 @@
 /********************************************************************
  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 "drm_backend.h"
 #include "drm_output.h"
 #include "drm_object_connector.h"
 #include "drm_object_crtc.h"
 #include "drm_object_plane.h"
 #include "composite.h"
 #include "cursor.h"
 #include "logging.h"
 #include "logind.h"
 #include "main.h"
 #include "scene_qpainter_drm_backend.h"
 #include "screens_drm.h"
 #include "udev.h"
 #include "wayland_server.h"
 #if HAVE_GBM
 #include "egl_gbm_backend.h"
 #include <gbm.h>
 #endif
 // KWayland
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/outputconfiguration_interface.h>
 // KF5
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 // Qt
 #include <QCryptographicHash>
 #include <QSocketNotifier>
 #include <QPainter>
 // system
 #include <unistd.h>
 // drm
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <libdrm/drm_mode.h>
 
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
 #ifndef DRM_CAP_CURSOR_HEIGHT
 #define DRM_CAP_CURSOR_HEIGHT 0x9
 #endif
 
 namespace KWin
 {
 
 DrmBackend::DrmBackend(QObject *parent)
     : Platform(parent)
     , m_udev(new Udev)
     , m_udevMonitor(m_udev->monitor())
     , m_dpmsFilter()
 {
     handleOutputs();
     m_cursor[0] = nullptr;
     m_cursor[1] = nullptr;
 }
 
 DrmBackend::~DrmBackend()
 {
 #if HAVE_GBM
     if (m_gbmDevice) {
         gbm_device_destroy(m_gbmDevice);
     }
 #endif
     if (m_fd >= 0) {
         // wait for pageflips
         while (m_pageFlipsPending != 0) {
             QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
         }
         qDeleteAll(m_planes);
         qDeleteAll(m_outputs);
         delete m_cursor[0];
         delete m_cursor[1];
         close(m_fd);
     }
 }
 
 void DrmBackend::init()
 {
     LogindIntegration *logind = LogindIntegration::self();
     auto takeControl = [logind, this]() {
         if (logind->hasSessionControl()) {
             openDrm();
         } else {
             logind->takeControl();
             connect(logind, &LogindIntegration::hasSessionControlChanged, this, &DrmBackend::openDrm);
         }
     };
     if (logind->isConnected()) {
         takeControl();
     } else {
         connect(logind, &LogindIntegration::connectedChanged, this, takeControl);
     }
 }
 
 void DrmBackend::outputWentOff()
 {
     if (!m_dpmsFilter.isNull()) {
         // already another output is off
         return;
     }
     m_dpmsFilter.reset(new DpmsInputEventFilter(this));
-    input()->prepandInputEventFilter(m_dpmsFilter.data());
+    input()->prependInputEventFilter(m_dpmsFilter.data());
 }
 
 void DrmBackend::turnOutputsOn()
 {
     m_dpmsFilter.reset();
     for (auto it = m_outputs.constBegin(), end = m_outputs.constEnd(); it != end; it++) {
         (*it)->setDpms(DrmOutput::DpmsMode::On);
     }
 }
 
 void DrmBackend::checkOutputsAreOn()
 {
     if (m_dpmsFilter.isNull()) {
         // already disabled, all outputs are on
         return;
     }
     for (auto it = m_outputs.constBegin(), end = m_outputs.constEnd(); it != end; it++) {
         if (!(*it)->isDpmsEnabled()) {
             // dpms still disabled, need to keep the filter
             return;
         }
     }
     // all outputs are on, disable the filter
     m_dpmsFilter.reset();
 }
 
 void DrmBackend::activate(bool active)
 {
     if (active) {
         reactivate();
     } else {
         deactivate();
     }
 }
 
 void DrmBackend::reactivate()
 {
     if (m_active) {
         return;
     }
     m_active = true;
     if (!usesSoftwareCursor()) {
         DrmBuffer *c = m_cursor[(m_cursorIndex + 1) % 2];
         const QPoint cp = Cursor::pos() - softwareCursorHotspot();
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             DrmOutput *o = *it;
             o->pageFlipped();
             o->blank();
             o->showCursor(c);
             o->moveCursor(cp);
         }
     }
     // restart compositor
     m_pageFlipsPending = 0;
     if (Compositor *compositor = Compositor::self()) {
         compositor->bufferSwapComplete();
         compositor->addRepaintFull();
     }
 }
 
 void DrmBackend::deactivate()
 {
     if (!m_active) {
         return;
     }
     // block compositor
     if (m_pageFlipsPending == 0 && Compositor::self()) {
         Compositor::self()->aboutToSwapBuffers();
     }
     // hide cursor and disable
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         DrmOutput *o = *it;
         o->hideCursor();
         o->restoreSaved();
     }
     m_active = false;
 }
 
 void DrmBackend::pageFlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
 {
     Q_UNUSED(fd)
     Q_UNUSED(frame)
     Q_UNUSED(sec)
     Q_UNUSED(usec)
     auto output = reinterpret_cast<DrmOutput*>(data);
     output->pageFlipped();
     output->m_backend->m_pageFlipsPending--;
     if (output->m_backend->m_pageFlipsPending == 0) {
         // TODO: improve, this currently means we wait for all page flips or all outputs.
         // It would be better to driver the repaint per output
         if (Compositor::self()) {
             Compositor::self()->bufferSwapComplete();
         }
     }
 }
 
 void DrmBackend::openDrm()
 {
     connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, this, &DrmBackend::activate);
     UdevDevice::Ptr device = m_udev->primaryGpu();
     if (!device) {
         qCWarning(KWIN_DRM) << "Did not find a GPU";
         return;
     }
     int fd = LogindIntegration::self()->takeDevice(device->devNode());
     if (fd < 0) {
         qCWarning(KWIN_DRM) << "failed to open drm device at" << device->devNode();
         return;
     }
     m_fd = fd;
     m_active = true;
     QSocketNotifier *notifier = new QSocketNotifier(m_fd, QSocketNotifier::Read, this);
     connect(notifier, &QSocketNotifier::activated, this,
         [this] {
             if (!LogindIntegration::self()->isActiveSession()) {
                 return;
             }
             drmEventContext e;
             memset(&e, 0, sizeof e);
             e.version = DRM_EVENT_CONTEXT_VERSION;
             e.page_flip_handler = pageFlipHandler;
             drmHandleEvent(m_fd, &e);
         }
     );
     m_drmId = device->sysNum();
 
     // trying to activate Atomic Mode Setting (this means also Universal Planes)
     if (qEnvironmentVariableIsSet("KWIN_DRM_AMS")) {
         if (drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1) == 0) {
             qCDebug(KWIN_DRM) << "Using Atomic Mode Setting.";
             m_atomicModeSetting = true;
 
             ScopedDrmPointer<drmModePlaneRes, &drmModeFreePlaneResources> planeResources(drmModeGetPlaneResources(m_fd));
             if (!planeResources) {
                 qCWarning(KWIN_DRM) << "Failed to get plane resources. Falling back to legacy mode";
                 m_atomicModeSetting = false;
             }
 
             if (m_atomicModeSetting) {
                 qCDebug(KWIN_DRM) << "Number of planes:" << planeResources->count_planes;
 
                 // create the plane objects
                 for (unsigned int i = 0; i < planeResources->count_planes; ++i) {
                     drmModePlane *kplane = drmModeGetPlane(m_fd, planeResources->planes[i]);
                     DrmPlane *p = new DrmPlane(kplane->plane_id, m_fd);
 
                     if (p->init()) {
                         p->setPossibleCrtcs(kplane->possible_crtcs);
                         p->setFormats(kplane->formats, kplane->count_formats);
                         m_planes << p;
                     } else {
                         delete p;
                     }
                 }
 
                 if (m_planes.isEmpty()) {
                     qCWarning(KWIN_DRM) << "Failed to create any plane. Falling back to legacy mode";
                     m_atomicModeSetting = false;
                 }
             }
         } else {
             qCWarning(KWIN_DRM) << "drmSetClientCap for Atomic Mode Setting failed. Using legacy mode.";
         }
     }
 
     queryResources();
     if (m_outputs.isEmpty()) {
         qCWarning(KWIN_DRM) << "No outputs, cannot render, will terminate now";
         emit initFailed();
         return;
     }
 
     // setup udevMonitor
     if (m_udevMonitor) {
         m_udevMonitor->filterSubsystemDevType("drm");
         const int fd = m_udevMonitor->fd();
         if (fd != -1) {
             QSocketNotifier *notifier = new QSocketNotifier(fd, QSocketNotifier::Read, this);
             connect(notifier, &QSocketNotifier::activated, this,
                 [this] {
                     auto device = m_udevMonitor->getDevice();
                     if (!device) {
                         return;
                     }
                     if (device->sysNum() != m_drmId) {
                         return;
                     }
                     if (device->hasProperty("HOTPLUG", "1")) {
                         qCDebug(KWIN_DRM) << "Received hot plug event for monitored drm device";
                         queryResources();
                         m_cursorIndex = (m_cursorIndex + 1) % 2;
                         updateCursor();
                     }
                 }
             );
             m_udevMonitor->enable();
         }
     }
     setReady(true);
 
     initCursor();
 }
 
 void DrmBackend::queryResources()
 {
     if (m_fd < 0) {
         return;
     }
     ScopedDrmPointer<_drmModeRes, &drmModeFreeResources> resources(drmModeGetResources(m_fd));
     if (!resources) {
         qCWarning(KWIN_DRM) << "drmModeGetResources failed";
         return;
     }
 
     QVector<DrmOutput*> connectedOutputs;
     for (int i = 0; i < resources->count_connectors; ++i) {
         const auto id = resources->connectors[i];
         ScopedDrmPointer<_drmModeConnector, &drmModeFreeConnector> connector(drmModeGetConnector(m_fd, id));
         if (!connector) {
             continue;
         }
         if (connector->connection != DRM_MODE_CONNECTED) {
             continue;
         }
         if (connector->count_modes == 0) {
             continue;
         }
         if (DrmOutput *o = findOutput(connector->connector_id)) {
             connectedOutputs << o;
             continue;
         }
         bool crtcFound = false;
         const quint32 crtcId = findCrtc(resources.data(), connector.data(), &crtcFound);
         if (!crtcFound) {
             continue;
         }
         ScopedDrmPointer<_drmModeCrtc, &drmModeFreeCrtc> crtc(drmModeGetCrtc(m_fd, crtcId));
         if (!crtc) {
             continue;
         }
         DrmOutput *drmOutput = new DrmOutput(this);
         connect(drmOutput, &DrmOutput::dpmsChanged, this, &DrmBackend::outputDpmsChanged);
         drmOutput->m_crtcId = crtcId;
         drmOutput->m_connector = connector->connector_id;
 
         if (m_atomicModeSetting) {
             drmOutput->m_crtc = new DrmCrtc(crtcId, m_fd);
             if (drmOutput->m_crtc->init()) {
                 drmOutput->m_crtc->setOutput(drmOutput);
             } else {
                 qCWarning(KWIN_DRM) << "Crtc object failed, skipping output on connector" << connector->connector_id;
                 delete drmOutput->m_crtc;
                 delete drmOutput;
                 continue;
             }
 
             drmOutput->m_conn = new DrmConnector(connector->connector_id, m_fd);
             if (drmOutput->m_conn->init()) {
                 drmOutput->m_conn->setOutput(drmOutput);
             } else {
                 qCWarning(KWIN_DRM) << "Connector object failed, skipping output on connector" << connector->connector_id;
                 delete drmOutput->m_conn;
                 delete drmOutput;
                 continue;
             }
         }
 
         if (crtc->mode_valid) {
             drmOutput->m_mode = crtc->mode;
         } else {
             drmOutput->m_mode = connector->modes[0];
         }
         qCDebug(KWIN_DRM) << "For new output use mode " << drmOutput->m_mode.name;
 
         if (!drmOutput->init(connector.data())) {
             qCWarning(KWIN_DRM) << "Failed to create output for connector " << connector->connector_id;
             delete drmOutput;
             continue;
         }
         qCDebug(KWIN_DRM) << "Found new output with uuid" << drmOutput->uuid();
         connectedOutputs << drmOutput;
     }
     std::sort(connectedOutputs.begin(), connectedOutputs.end(), [] (DrmOutput *a, DrmOutput *b) { return a->m_connector < b->m_connector; });
     // check for outputs which got removed
     auto it = m_outputs.begin();
     while (it != m_outputs.end()) {
         if (connectedOutputs.contains(*it)) {
             it++;
             continue;
         }
         DrmOutput *removed = *it;
         it = m_outputs.erase(it);
         emit outputRemoved(removed);
         delete removed;
     }
     for (auto it = connectedOutputs.constBegin(); it != connectedOutputs.constEnd(); ++it) {
         if (!m_outputs.contains(*it)) {
             emit outputAdded(*it);
         }
     }
     m_outputs = connectedOutputs;
     readOutputsConfiguration();
     if (!m_outputs.isEmpty()) {
         emit screensQueried();
     }
 }
 
 void DrmBackend::readOutputsConfiguration()
 {
     if (m_outputs.isEmpty()) {
         return;
     }
     const QByteArray uuid = generateOutputConfigurationUuid();
     const auto outputGroup = kwinApp()->config()->group("DrmOutputs");
     const auto configGroup = outputGroup.group(uuid);
     qCDebug(KWIN_DRM) << "Reading output configuration for" << uuid;
     // default position goes from left to right
     QPoint pos(0, 0);
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         const auto outputConfig = configGroup.group((*it)->uuid());
         (*it)->setGlobalPos(outputConfig.readEntry<QPoint>("Position", pos));
         // TODO: add mode
         pos.setX(pos.x() + (*it)->size().width());
     }
 }
 
 QByteArray DrmBackend::generateOutputConfigurationUuid() const
 {
     auto it = m_outputs.constBegin();
     if (m_outputs.size() == 1) {
         // special case: one output
         return (*it)->uuid();
     }
     QCryptographicHash hash(QCryptographicHash::Md5);
     for (; it != m_outputs.constEnd(); ++it) {
         hash.addData((*it)->uuid());
     }
     return hash.result().toHex().left(10);
 }
 
 void DrmBackend::configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config)
 {
     const auto changes = config->changes();
     for (auto it = changes.begin(); it != changes.end(); it++) {
 
         KWayland::Server::OutputChangeSet *changeset = it.value();
 
         auto drmoutput = findOutput(it.key()->uuid());
         if (drmoutput == nullptr) {
             qCWarning(KWIN_DRM) << "Could NOT find DrmOutput matching " << it.key()->uuid();
             return;
         }
         drmoutput->setChanges(changeset);
     }
     emit screens()->changed();
 }
 
 DrmOutput *DrmBackend::findOutput(quint32 connector)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [connector] (DrmOutput *o) {
         return o->m_connector == connector;
     });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 DrmOutput *DrmBackend::findOutput(const QByteArray &uuid)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [uuid] (DrmOutput *o) {
         return o->m_uuid == uuid;
     });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 quint32 DrmBackend::findCrtc(drmModeRes *res, drmModeConnector *connector, bool *ok)
 {
     if (ok) {
         *ok = false;
     }
     ScopedDrmPointer<_drmModeEncoder, &drmModeFreeEncoder> encoder(drmModeGetEncoder(m_fd, connector->encoder_id));
     if (encoder) {
         if (!crtcIsUsed(encoder->crtc_id)) {
             if (ok) {
                 *ok = true;
             }
             return encoder->crtc_id;
         }
     }
     // let's iterate over all encoders to find a suitable crtc
     for (int i = 0; i < connector->count_encoders; ++i) {
         ScopedDrmPointer<_drmModeEncoder, &drmModeFreeEncoder> encoder(drmModeGetEncoder(m_fd, connector->encoders[i]));
         if (!encoder) {
             continue;
         }
         for (int j = 0; j < res->count_crtcs; ++j) {
             if (!(encoder->possible_crtcs & (1 << j))) {
                 continue;
             }
             if (!crtcIsUsed(res->crtcs[j])) {
                 if (ok) {
                     *ok = true;
                 }
                 return res->crtcs[j];
             }
         }
     }
     return 0;
 }
 
 bool DrmBackend::crtcIsUsed(quint32 crtc)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(),
         [crtc] (DrmOutput *o) {
             return o->m_crtcId == crtc;
         }
     );
     return it != m_outputs.constEnd();
 }
 
 void DrmBackend::present(DrmBuffer *buffer, DrmOutput *output)
 {
     if (output->present(buffer)) {
         m_pageFlipsPending++;
         if (m_pageFlipsPending == 1 && Compositor::self()) {
             Compositor::self()->aboutToSwapBuffers();
         }
     }
 }
 
 void DrmBackend::initCursor()
 {
     m_cursorEnabled = waylandServer()->seat()->hasPointer();
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::hasPointerChanged, this,
         [this] {
             m_cursorEnabled = waylandServer()->seat()->hasPointer();
             if (usesSoftwareCursor()) {
                 return;
             }
             for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
                 if (m_cursorEnabled) {
                     (*it)->showCursor(m_cursor[m_cursorIndex]);
                 } else {
                     (*it)->hideCursor();
                 }
             }
         }
     );
     uint64_t capability = 0;
     QSize cursorSize;
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_WIDTH, &capability) == 0) {
         cursorSize.setWidth(capability);
     } else {
         cursorSize.setWidth(64);
     }
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_HEIGHT, &capability) == 0) {
         cursorSize.setHeight(capability);
     } else {
         cursorSize.setHeight(64);
     }
     auto createCursor = [this, cursorSize] (int index) {
         m_cursor[index] = createBuffer(cursorSize);
         if (!m_cursor[index]->map(QImage::Format_ARGB32_Premultiplied)) {
             return false;
         }
         m_cursor[index]->image()->fill(Qt::transparent);
         return true;
     };
     if (!createCursor(0) || !createCursor(1)) {
         setSoftWareCursor(true);
         return;
     }
     // now we have screens and can set cursors, so start tracking
     connect(this, &DrmBackend::cursorChanged, this, &DrmBackend::updateCursor);
     connect(Cursor::self(), &Cursor::posChanged, this, &DrmBackend::moveCursor);
 }
 
 void DrmBackend::setCursor()
 {
     DrmBuffer *c = m_cursor[m_cursorIndex];
     m_cursorIndex = (m_cursorIndex + 1) % 2;
     if (m_cursorEnabled) {
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             (*it)->showCursor(c);
         }
     }
     markCursorAsRendered();
 }
 
 void DrmBackend::updateCursor()
 {
     if (usesSoftwareCursor()) {
         return;
     }
     if (isCursorHidden()) {
         return;
     }
     const QImage &cursorImage = softwareCursor();
     if (cursorImage.isNull()) {
         doHideCursor();
         return;
     }
     QImage *c = m_cursor[m_cursorIndex]->image();
     c->fill(Qt::transparent);
     QPainter p;
     p.begin(c);
     p.drawImage(QPoint(0, 0), cursorImage);
     p.end();
 
     setCursor();
     moveCursor();
 }
 
 void DrmBackend::doShowCursor()
 {
     updateCursor();
 }
 
 void DrmBackend::doHideCursor()
 {
     if (!m_cursorEnabled) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->hideCursor();
     }
 }
 
 void DrmBackend::moveCursor()
 {
     const QPoint p = Cursor::pos() - softwareCursorHotspot();
     if (!m_cursorEnabled || isCursorHidden()) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->moveCursor(p);
     }
 }
 
 Screens *DrmBackend::createScreens(QObject *parent)
 {
     return new DrmScreens(this, parent);
 }
 
 QPainterBackend *DrmBackend::createQPainterBackend()
 {
     return new DrmQPainterBackend(this);
 }
 
 OpenGLBackend *DrmBackend::createOpenGLBackend()
 {
 #if HAVE_GBM
     return new EglGbmBackend(this);
 #else
     return Platform::createOpenGLBackend();
 #endif
 }
 
 DrmBuffer *DrmBackend::createBuffer(const QSize &size)
 {
     DrmBuffer *b = new DrmBuffer(this, size);
     m_buffers << b;
     return b;
 }
 
 DrmBuffer *DrmBackend::createBuffer(gbm_surface *surface)
 {
 #if HAVE_GBM
     DrmBuffer *b = new DrmBuffer(this, surface);
     b->m_deleteAfterPageFlip = true;
     m_buffers << b;
     return b;
 #else
     return nullptr;
 #endif
 }
 
 void DrmBackend::bufferDestroyed(DrmBuffer *b)
 {
     m_buffers.removeAll(b);
 }
 
 void DrmBackend::outputDpmsChanged()
 {
     if (m_outputs.isEmpty()) {
         return;
     }
     bool enabled = false;
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         enabled = enabled || (*it)->isDpmsEnabled();
     }
     setOutputsEnabled(enabled);
 }
 
 
 }
diff --git a/plugins/platforms/hwcomposer/hwcomposer_backend.cpp b/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
index 701d69838..66b8d11e1 100644
--- a/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
+++ b/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
@@ -1,476 +1,476 @@
 /********************************************************************
  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 3 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 "egl_hwcomposer_backend.h"
 #include "hwcomposer_backend.h"
 #include "logging.h"
 #include "screens_hwcomposer.h"
 #include "composite.h"
 #include "input.h"
 #include "main.h"
 #include "wayland_server.h"
 // KWayland
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/output_interface.h>
 #include <KWayland/Server/seat_interface.h>
 // Qt
 #include <QKeyEvent>
 #include <QDBusConnection>
 // hybris/android
 #include <hardware/hardware.h>
 #include <hardware/hwcomposer.h>
 #include <hardware/lights.h>
 // linux
 #include <linux/input.h>
 
 // based on test_hwcomposer.c from libhybris project (Apache 2 licensed)
 
 namespace KWin
 {
 
 BacklightInputEventFilter::BacklightInputEventFilter(HwcomposerBackend *backend)
     : InputEventFilter()
     , m_backend(backend)
 {
 }
 
 BacklightInputEventFilter::~BacklightInputEventFilter() = default;
 
 bool BacklightInputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     toggleBacklight();
     return true;
 }
 
 bool BacklightInputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     toggleBacklight();
     return true;
 }
 
 bool BacklightInputEventFilter::keyEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_PowerOff && event->type() == QEvent::KeyRelease) {
         toggleBacklight();
         return true;
     }
     return m_backend->isBacklightOff();
 }
 
 bool BacklightInputEventFilter::touchDown(quint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(pos)
     Q_UNUSED(time)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     if (m_touchPoints.isEmpty()) {
         if (!m_doubleTapTimer.isValid()) {
             // this is the first tap
             m_doubleTapTimer.start();
         } else {
             if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
                 m_secondTap = true;
             } else {
                 // took too long. Let's consider it a new click
                 m_doubleTapTimer.restart();
             }
         }
     } else {
         // not a double tap
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     m_touchPoints << id;
     return true;
 }
 
 bool BacklightInputEventFilter::touchUp(quint32 id, quint32 time)
 {
     Q_UNUSED(time)
     m_touchPoints.removeAll(id);
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     if (m_touchPoints.isEmpty() && m_doubleTapTimer.isValid() && m_secondTap) {
         if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
             toggleBacklight();
         }
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     return true;
 }
 
 bool BacklightInputEventFilter::touchMotion(quint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(pos)
     Q_UNUSED(time)
     return m_backend->isBacklightOff();
 }
 
 void BacklightInputEventFilter::toggleBacklight()
 {
     // queued to not modify the list of event filters while filtering
     QMetaObject::invokeMethod(m_backend, "toggleBlankOutput", Qt::QueuedConnection);
 }
 
 HwcomposerBackend::HwcomposerBackend(QObject *parent)
     : Platform(parent)
 {
     if (!QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.Solid.PowerManagement"),
                                               QStringLiteral("/org/kde/Solid/PowerManagement/Actions/BrightnessControl"),
                                               QStringLiteral("org.kde.Solid.PowerManagement.Actions.BrightnessControl"),
                                               QStringLiteral("brightnessChanged"), this,
                                               SLOT(screenBrightnessChanged(int)))) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to connect to brightness control";
     }
     handleOutputs();
 }
 
 HwcomposerBackend::~HwcomposerBackend()
 {
     if (!m_outputBlank) {
         toggleBlankOutput();
     }
     if (m_device) {
         hwc_close_1(m_device);
     }
 }
 
 static KWayland::Server::OutputInterface *createOutput(hwc_composer_device_1_t *device)
 {
     uint32_t configs[5];
     size_t numConfigs = 5;
     if (device->getDisplayConfigs(device, 0, configs, &numConfigs) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get hwcomposer display configurations";
         return nullptr;
     }
 
     int32_t attr_values[5];
     uint32_t attributes[] = {
         HWC_DISPLAY_WIDTH,
         HWC_DISPLAY_HEIGHT,
         HWC_DISPLAY_DPI_X,
         HWC_DISPLAY_DPI_Y,
         HWC_DISPLAY_VSYNC_PERIOD ,
         HWC_DISPLAY_NO_ATTRIBUTE
     };
     device->getDisplayAttributes(device, 0, configs[0], attributes, attr_values);
     QSize pixel(attr_values[0], attr_values[1]);
     if (pixel.isEmpty()) {
         return nullptr;
     }
 
     using namespace KWayland::Server;
     OutputInterface *o = waylandServer()->display()->createOutput(waylandServer()->display());
     o->addMode(pixel, OutputInterface::ModeFlag::Current | OutputInterface::ModeFlag::Preferred, (attr_values[4] == 0) ? 60000 : 10E11/attr_values[4]);
 
     if (attr_values[2] != 0 && attr_values[3] != 0) {
          static const qreal factor = 25.4;
          o->setPhysicalSize(QSizeF(qreal(pixel.width() * 1000) / qreal(attr_values[2]) * factor,
                                    qreal(pixel.height() * 1000) / qreal(attr_values[3]) * factor).toSize());
     } else {
          // couldn't read physical size, assume 96 dpi
          o->setPhysicalSize(pixel / 3.8);
     }
     o->create();
     return o;
 }
 
 void HwcomposerBackend::init()
 {
     hw_module_t *hwcModule = nullptr;
     if (hw_get_module(HWC_HARDWARE_MODULE_ID, (const hw_module_t **)&hwcModule) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get hwcomposer module";
         emit initFailed();
         return;
     }
 
     hwc_composer_device_1_t *hwcDevice = nullptr;
     if (hwc_open_1(hwcModule, &hwcDevice) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to open hwcomposer device";
         emit initFailed();
         return;
     }
 
     // unblank, setPowerMode?
     m_device = hwcDevice;
 
     m_hwcVersion = m_device->common.version;
     if ((m_hwcVersion & 0xffff0000) == 0) {
         // Assume header version is always 1
         uint32_t header_version = 1;
         // Legacy version encoding
         m_hwcVersion = (m_hwcVersion << 16) | header_version;
     }
 
     // register callbacks
     hwc_procs_t *procs = new hwc_procs_t;
     procs->invalidate = [] (const struct hwc_procs* procs) {
         Q_UNUSED(procs)
     };
     procs->vsync = [] (const struct hwc_procs* procs, int disp, int64_t timestamp) {
         Q_UNUSED(procs)
         if (disp != 0) {
             return;
         }
         dynamic_cast<HwcomposerBackend*>(kwinApp()->platform())->wakeVSync();
     };
     procs->hotplug = [] (const struct hwc_procs* procs, int disp, int connected) {
         Q_UNUSED(procs)
         Q_UNUSED(disp)
         Q_UNUSED(connected)
     };
     m_device->registerProcs(m_device, procs);
 
     initLights();
     toggleBlankOutput();
     m_filter.reset(new BacklightInputEventFilter(this));
-    input()->prepandInputEventFilter(m_filter.data());
+    input()->prependInputEventFilter(m_filter.data());
 
     // get display configuration
     auto output = createOutput(hwcDevice);
     if (!output) {
         emit initFailed();
         return;
     }
     m_displaySize = output->pixelSize();
     m_refreshRate = output->refreshRate();
     if (m_refreshRate != 0) {
         m_vsyncInterval = 1000000/m_refreshRate;
     }
     if (m_lights) {
         using namespace KWayland::Server;
         output->setDpmsSupported(true);
         auto updateDpms = [this, output] {
             output->setDpmsMode(m_outputBlank ? OutputInterface::DpmsMode::Off : OutputInterface::DpmsMode::On);
         };
         updateDpms();
         connect(this, &HwcomposerBackend::outputBlankChanged, this, updateDpms);
         connect(output, &OutputInterface::dpmsModeRequested, this,
             [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
                 if (mode == OutputInterface::DpmsMode::On) {
                     if (m_outputBlank) {
                         toggleBlankOutput();
                     }
                 } else {
                     if (!m_outputBlank) {
                         toggleBlankOutput();
                     }
                 }
             }
         );
     }
     qCDebug(KWIN_HWCOMPOSER) << "Display size:" << m_displaySize;
     qCDebug(KWIN_HWCOMPOSER) << "Refresh rate:" << m_refreshRate;
 
     emit screensQueried();
     setReady(true);
 }
 
 void HwcomposerBackend::initLights()
 {
     hw_module_t *lightsModule = nullptr;
     if (hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (const hw_module_t **)&lightsModule) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get lights module";
         return;
     }
     light_device_t *lightsDevice = nullptr;
     if (lightsModule->methods->open(lightsModule, LIGHT_ID_BACKLIGHT, (hw_device_t **)&lightsDevice) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to create lights device";
         return;
     }
     m_lights = lightsDevice;
 }
 
 void HwcomposerBackend::toggleBlankOutput()
 {
     if (!m_device) {
         return;
     }
     m_outputBlank = !m_outputBlank;
     toggleScreenBrightness();
 
 #if defined(HWC_DEVICE_API_VERSION_1_4) || defined(HWC_DEVICE_API_VERSION_1_5)
     if (m_hwcVersion > HWC_DEVICE_API_VERSION_1_3)
         m_device->setPowerMode(m_device, 0, m_outputBlank ? HWC_POWER_MODE_OFF : HWC_POWER_MODE_NORMAL);
     else
 #endif
         m_device->blank(m_device, 0, m_outputBlank ? 1 : 0);
 
     // only disable Vsync, enable happens after next frame rendered
     if (m_outputBlank) {
          enableVSync(false);
     }
     // enable/disable compositor repainting when blanked
     setOutputsEnabled(!m_outputBlank);
     if (Compositor *compositor = Compositor::self()) {
         if (!m_outputBlank) {
             compositor->addRepaintFull();
         }
     }
     emit outputBlankChanged();
 }
 
 void HwcomposerBackend::toggleScreenBrightness()
 {
     if (!m_lights) {
         return;
     }
     const int brightness = m_outputBlank ? 0 : m_oldScreenBrightness;
     struct light_state_t state;
     state.flashMode = LIGHT_FLASH_NONE;
     state.brightnessMode = BRIGHTNESS_MODE_USER;
 
     state.color = (int)((0xffU << 24) | (brightness << 16) |
                         (brightness << 8) | brightness);
     m_lights->set_light(m_lights, &state);
 }
 
 void HwcomposerBackend::enableVSync(bool enable)
 {
     if (m_hasVsync == enable) {
         return;
     }
     const int result = m_device->eventControl(m_device, 0, HWC_EVENT_VSYNC, enable ? 1: 0);
     m_hasVsync = enable && (result == 0);
 }
 
 HwcomposerWindow *HwcomposerBackend::createSurface()
 {
     return new HwcomposerWindow(this);
 }
 
 Screens *HwcomposerBackend::createScreens(QObject *parent)
 {
     return new HwcomposerScreens(this, parent);
 }
 
 OpenGLBackend *HwcomposerBackend::createOpenGLBackend()
 {
     return new EglHwcomposerBackend(this);
 }
 
 void HwcomposerBackend::waitVSync()
 {
     if (!m_hasVsync) {
          return;
     }
     m_vsyncMutex.lock();
     m_vsyncWaitCondition.wait(&m_vsyncMutex, m_vsyncInterval);
     m_vsyncMutex.unlock();
 }
 
 void HwcomposerBackend::wakeVSync()
 {
     m_vsyncMutex.lock();
     m_vsyncWaitCondition.wakeAll();
     m_vsyncMutex.unlock();
 }
 
 static void initLayer(hwc_layer_1_t *layer, const hwc_rect_t &rect)
 {
     memset(layer, 0, sizeof(hwc_layer_1_t));
     layer->compositionType = HWC_FRAMEBUFFER;
     layer->hints = 0;
     layer->flags = 0;
     layer->handle = 0;
     layer->transform = 0;
     layer->blending = HWC_BLENDING_NONE;
     layer->sourceCrop = rect;
     layer->displayFrame = rect;
     layer->visibleRegionScreen.numRects = 1;
     layer->visibleRegionScreen.rects = &layer->displayFrame;
     layer->acquireFenceFd = -1;
     layer->releaseFenceFd = -1;
     layer->planeAlpha = 0xFF;
 }
 
 HwcomposerWindow::HwcomposerWindow(HwcomposerBackend *backend)
     : HWComposerNativeWindow(backend->size().width(), backend->size().height(), HAL_PIXEL_FORMAT_RGBA_8888)
     , m_backend(backend)
 {
     setBufferCount(3);
 
     size_t size = sizeof(hwc_display_contents_1_t) + 2 * sizeof(hwc_layer_1_t);
     hwc_display_contents_1_t *list = (hwc_display_contents_1_t*)malloc(size);
     m_list = (hwc_display_contents_1_t**)malloc(HWC_NUM_DISPLAY_TYPES * sizeof(hwc_display_contents_1_t *));
     for (int i = 0; i < HWC_NUM_DISPLAY_TYPES; ++i) {
         m_list[i] = nullptr;
     }
     // Assign buffer only to the first item, otherwise you get tearing
     // if passed the same to multiple places
     // see https://github.com/mer-hybris/qt5-qpa-hwcomposer-plugin/commit/f1d802151e8a4f5d10d60eb8de8e07552b93a34a
     m_list[0] = list;
     const hwc_rect_t rect = {
         0,
         0,
         m_backend->size().width(),
         m_backend->size().height()
     };
     initLayer(&list->hwLayers[0], rect);
     initLayer(&list->hwLayers[1], rect);
 
     list->retireFenceFd = -1;
     list->flags = HWC_GEOMETRY_CHANGED;
     list->numHwLayers = 2;
 }
 
 HwcomposerWindow::~HwcomposerWindow()
 {
     // TODO: cleanup
 }
 
 void HwcomposerWindow::present(HWComposerNativeWindowBuffer *buffer)
 {
     m_backend->waitVSync();
     hwc_composer_device_1_t *device = m_backend->device();
 
     auto fblayer = &m_list[0]->hwLayers[1];
     fblayer->handle = buffer->handle;
     fblayer->acquireFenceFd = getFenceBufferFd(buffer);
     fblayer->releaseFenceFd = -1;
 
     int err = device->prepare(device, 1, m_list);
     assert(err == 0);
 
     err = device->set(device, 1, m_list);
     assert(err == 0);
     m_backend->enableVSync(true);
     setFenceBufferFd(buffer, fblayer->releaseFenceFd);
 
     if (m_list[0]->retireFenceFd != -1) {
         close(m_list[0]->retireFenceFd);
         m_list[0]->retireFenceFd = -1;
     }
     m_list[0]->flags = 0;
 }
 
 }