diff --git a/gestures.cpp b/gestures.cpp
index 9d49532ea..271d880e8 100644
--- a/gestures.cpp
+++ b/gestures.cpp
@@ -1,210 +1,213 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 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 "gestures.h"
 
 #include <QRect>
 #include <functional>
 #include <cmath>
 
 namespace KWin
 {
 
 Gesture::Gesture(QObject *parent)
     : QObject(parent)
 {
 }
 
 Gesture::~Gesture() = default;
 
 SwipeGesture::SwipeGesture(QObject *parent)
     : Gesture(parent)
 {
 }
 
 SwipeGesture::~SwipeGesture() = default;
 
 void SwipeGesture::setStartGeometry(const QRect &geometry)
 {
     setMinimumX(geometry.x());
     setMinimumY(geometry.y());
     setMaximumX(geometry.x() + geometry.width());
     setMaximumY(geometry.y() + geometry.height());
+
+    Q_ASSERT(m_maximumX >= m_minimumX);
+    Q_ASSERT(m_maximumY >= m_minimumY);
 }
 
 qreal SwipeGesture::minimumDeltaReachedProgress(const QSizeF &delta) const
 {
     if (!m_minimumDeltaRelevant || m_minimumDelta.isNull()) {
         return 1.0;
     }
     switch (m_direction) {
     case Direction::Up:
     case Direction::Down:
         return std::min(std::abs(delta.height()) / std::abs(m_minimumDelta.height()), 1.0);
     case Direction::Left:
     case Direction::Right:
         return std::min(std::abs(delta.width()) / std::abs(m_minimumDelta.width()), 1.0);
     default:
         Q_UNREACHABLE();
     }
 }
 
 bool SwipeGesture::minimumDeltaReached(const QSizeF &delta) const
 {
     return minimumDeltaReachedProgress(delta) >= 1.0;
 }
 
 GestureRecognizer::GestureRecognizer(QObject *parent)
     : QObject(parent)
 {
 }
 
 GestureRecognizer::~GestureRecognizer() = default;
 
 void GestureRecognizer::registerGesture(KWin::Gesture* gesture)
 {
     Q_ASSERT(!m_gestures.contains(gesture));
     auto connection = connect(gesture, &QObject::destroyed, this, std::bind(&GestureRecognizer::unregisterGesture, this, gesture));
     m_destroyConnections.insert(gesture, connection);
     m_gestures << gesture;
 }
 
 void GestureRecognizer::unregisterGesture(KWin::Gesture* gesture)
 {
     auto it = m_destroyConnections.find(gesture);
     if (it != m_destroyConnections.end()) {
         disconnect(it.value());
         m_destroyConnections.erase(it);
     }
     m_gestures.removeAll(gesture);
     if (m_activeSwipeGestures.removeOne(gesture)) {
         emit gesture->cancelled();
     }
 }
 
 int GestureRecognizer::startSwipeGesture(uint fingerCount, const QPointF &startPos, StartPositionBehavior startPosBehavior)
 {
     int count = 0;
     // TODO: verify that no gesture is running
     for (Gesture *gesture : qAsConst(m_gestures)) {
         SwipeGesture *swipeGesture = qobject_cast<SwipeGesture*>(gesture);
         if (!gesture) {
             continue;
         }
         if (swipeGesture->minimumFingerCountIsRelevant()) {
             if (swipeGesture->minimumFingerCount() > fingerCount) {
                 continue;
             }
         }
         if (swipeGesture->maximumFingerCountIsRelevant()) {
             if (swipeGesture->maximumFingerCount() < fingerCount) {
                 continue;
             }
         }
         if (startPosBehavior == StartPositionBehavior::Relevant) {
             if (swipeGesture->minimumXIsRelevant()) {
                 if (swipeGesture->minimumX() > startPos.x()) {
                     continue;
                 }
             }
             if (swipeGesture->maximumXIsRelevant()) {
                 if (swipeGesture->maximumX() < startPos.x()) {
                     continue;
                 }
             }
             if (swipeGesture->minimumYIsRelevant()) {
                 if (swipeGesture->minimumY() > startPos.y()) {
                     continue;
                 }
             }
             if (swipeGesture->maximumYIsRelevant()) {
                 if (swipeGesture->maximumY() < startPos.y()) {
                     continue;
                 }
             }
         }
         // direction doesn't matter yet
         m_activeSwipeGestures << swipeGesture;
         count++;
         emit swipeGesture->started();
     }
     return count;
 }
 
 void GestureRecognizer::updateSwipeGesture(const QSizeF &delta)
 {
     m_swipeUpdates << delta;
     // determine the direction of the swipe
     if (delta.width() == delta.height()) {
         // special case of diagonal, this is not yet supported, thus cancel all gestures
         cancelActiveSwipeGestures();
         return;
     }
     SwipeGesture::Direction direction;
     if (std::abs(delta.width()) > std::abs(delta.height())) {
         // horizontal
         direction = delta.width() < 0 ? SwipeGesture::Direction::Left : SwipeGesture::Direction::Right;
     } else {
         // vertical
         direction = delta.height() < 0 ? SwipeGesture::Direction::Up : SwipeGesture::Direction::Down;
     }
     const QSizeF combinedDelta = std::accumulate(m_swipeUpdates.constBegin(), m_swipeUpdates.constEnd(), QSizeF(0, 0));
     for (auto it = m_activeSwipeGestures.begin(); it != m_activeSwipeGestures.end();) {
         auto g = qobject_cast<SwipeGesture*>(*it);
         if (g->direction() == direction) {
             if (g->isMinimumDeltaRelevant()) {
                 emit g->progress(g->minimumDeltaReachedProgress(combinedDelta));
             }
             it++;
         } else {
             emit g->cancelled();
             it = m_activeSwipeGestures.erase(it);
         }
     }
 }
 
 void GestureRecognizer::cancelActiveSwipeGestures()
 {
     for (auto g : qAsConst(m_activeSwipeGestures)) {
         emit g->cancelled();
     }
     m_activeSwipeGestures.clear();
 }
 
 void GestureRecognizer::cancelSwipeGesture()
 {
     cancelActiveSwipeGestures();
     m_swipeUpdates.clear();
 }
 
 void GestureRecognizer::endSwipeGesture()
 {
     const QSizeF delta = std::accumulate(m_swipeUpdates.constBegin(), m_swipeUpdates.constEnd(), QSizeF(0, 0));
     for (auto g : qAsConst(m_activeSwipeGestures)) {
         if (static_cast<SwipeGesture*>(g)->minimumDeltaReached(delta)) {
             emit g->triggered();
         } else {
             emit g->cancelled();
         }
     }
     m_activeSwipeGestures.clear();
     m_swipeUpdates.clear();
 }
 
 }
diff --git a/screenedge.cpp b/screenedge.cpp
index 46df5b97c..edbf0d35a 100644
--- a/screenedge.cpp
+++ b/screenedge.cpp
@@ -1,1495 +1,1494 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 Since the functionality provided in this class has been moved from
 class Workspace, it is not clear who exactly has written the code.
 The list below contains the copyright holders of the class Workspace.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 
 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 "screenedge.h"
 
 // KWin
 #include "gestures.h"
 #include <x11client.h>
 #include "cursor.h"
 #include "main.h"
 #include "platform.h"
 #include "screens.h"
 #include "utils.h"
 #include <workspace.h>
 #include "virtualdesktops.h"
 #ifdef KWIN_UNIT_TEST
 #include "plugins/platforms/x11/standalone/edge.h"
 #endif
 // DBus generated
 #include "screenlocker_interface.h"
 // frameworks
 #include <KConfigGroup>
 // Qt
 #include <QAction>
 #include <QMouseEvent>
 #include <QSharedPointer>
 #include <QTimer>
 #include <QVector>
 #include <QTextStream>
 #include <QDBusInterface>
 #include <QDBusPendingCall>
 #include <QWidget>
 
 namespace KWin {
 
 // Mouse should not move more than this many pixels
 static const int DISTANCE_RESET = 30;
 
 Edge::Edge(ScreenEdges *parent)
     : QObject(parent)
     , m_edges(parent)
     , m_border(ElectricNone)
     , m_action(ElectricActionNone)
     , m_reserved(0)
     , m_approaching(false)
     , m_lastApproachingFactor(0)
     , m_blocked(false)
     , m_pushBackBlocked(false)
     , m_client(nullptr)
     , m_gesture(new SwipeGesture(this))
 {
     m_gesture->setMinimumFingerCount(1);
     m_gesture->setMaximumFingerCount(1);
     connect(m_gesture, &Gesture::triggered, this,
         [this] {
             stopApproaching();
             if (m_client) {
                 m_client->showOnScreenEdge();
                 unreserve();
                 return;
             }
             handleTouchAction();
             handleTouchCallback();
         }, Qt::QueuedConnection
     );
     connect(m_gesture, &SwipeGesture::started, this, &Edge::startApproaching);
     connect(m_gesture, &SwipeGesture::cancelled, this, &Edge::stopApproaching);
     connect(m_gesture, &SwipeGesture::progress, this,
         [this] (qreal progress) {
             int factor = progress * 256.0f;
             if (m_lastApproachingFactor != factor) {
                 m_lastApproachingFactor = factor;
                 emit approaching(border(), m_lastApproachingFactor/256.0f, m_approachGeometry);
             }
         }
     );
     connect(this, &Edge::activatesForTouchGestureChanged, this,
         [this] {
             if (isReserved()) {
                 if (activatesForTouchGesture()) {
                     m_edges->gestureRecognizer()->registerGesture(m_gesture);
                 } else {
                     m_edges->gestureRecognizer()->unregisterGesture(m_gesture);
                 }
             }
         }
     );
 }
 
 Edge::~Edge()
 {
 }
 
 void Edge::reserve()
 {
     m_reserved++;
     if (m_reserved == 1) {
         // got activated
         activate();
     }
 }
 
 void Edge::reserve(QObject *object, const char *slot)
 {
     connect(object, SIGNAL(destroyed(QObject*)), SLOT(unreserve(QObject*)));
     m_callBacks.insert(object, QByteArray(slot));
     reserve();
 }
 
 void Edge::reserveTouchCallBack(QAction *action)
 {
     if (m_touchActions.contains(action)) {
         return;
     }
     connect(action, &QAction::destroyed, this,
         [this, action] {
             unreserveTouchCallBack(action);
         }
     );
     m_touchActions << action;
     reserve();
 }
 
 void Edge::unreserveTouchCallBack(QAction *action)
 {
     auto it = std::find_if(m_touchActions.begin(), m_touchActions.end(), [action] (QAction *a) { return a == action; });
     if (it != m_touchActions.end()) {
         m_touchActions.erase(it);
         unreserve();
     }
 }
 
 void Edge::unreserve()
 {
     m_reserved--;
     if (m_reserved == 0) {
         // got deactivated
         stopApproaching();
         deactivate();
     }
 }
 void Edge::unreserve(QObject *object)
 {
     if (m_callBacks.contains(object)) {
         m_callBacks.remove(object);
         disconnect(object, SIGNAL(destroyed(QObject*)), this, SLOT(unreserve(QObject*)));
         unreserve();
     }
 }
 
 bool Edge::activatesForPointer() const
 {
     if (m_client) {
         return true;
     }
     if (m_edges->isDesktopSwitching()) {
         return true;
     }
     if (m_edges->isDesktopSwitchingMovingClients()) {
         auto c = Workspace::self()->moveResizeClient();
         if (c && !c->isResize()) {
             return true;
         }
     }
     if (!m_callBacks.isEmpty()) {
         return true;
     }
     if (m_action != ElectricActionNone) {
         return true;
     }
     return false;
 }
 
 bool Edge::activatesForTouchGesture() const
 {
     if (!isScreenEdge()) {
         return false;
     }
     if (m_blocked) {
         return false;
     }
     if (m_client) {
         return true;
     }
     if (m_touchAction != ElectricActionNone) {
         return true;
     }
     if (!m_touchActions.isEmpty()) {
         return true;
     }
     return false;
 }
 
 bool Edge::triggersFor(const QPoint &cursorPos) const
 {
     if (isBlocked()) {
         return false;
     }
     if (!activatesForPointer()) {
         return false;
     }
     if (!m_geometry.contains(cursorPos)) {
         return false;
     }
     if (isLeft() && cursorPos.x() != m_geometry.x()) {
         return false;
     }
     if (isRight() && cursorPos.x() != (m_geometry.x() + m_geometry.width() -1)) {
         return false;
     }
     if (isTop() && cursorPos.y() != m_geometry.y()) {
         return false;
     }
     if (isBottom() && cursorPos.y() != (m_geometry.y() + m_geometry.height() -1)) {
         return false;
     }
     return true;
 }
 
 bool Edge::check(const QPoint &cursorPos, const QDateTime &triggerTime, bool forceNoPushBack)
 {
     if (!triggersFor(cursorPos)) {
         return false;
     }
     if (m_lastTrigger.isValid() && // still in cooldown
         m_lastTrigger.msecsTo(triggerTime) < edges()->reActivationThreshold() - edges()->timeThreshold()) {
         return false;
     }
     // no pushback so we have to activate at once
     bool directActivate = forceNoPushBack || edges()->cursorPushBackDistance().isNull() || m_client;
     if (directActivate || canActivate(cursorPos, triggerTime)) {
         markAsTriggered(cursorPos, triggerTime);
         handle(cursorPos);
         return true;
     } else {
         pushCursorBack(cursorPos);
         m_triggeredPoint = cursorPos;
     }
     return false;
 }
 
 void Edge::markAsTriggered(const QPoint &cursorPos, const QDateTime &triggerTime)
 {
     m_lastTrigger = triggerTime;
     m_lastReset = QDateTime(); // invalidate
     m_triggeredPoint = cursorPos;
 }
 
 bool Edge::canActivate(const QPoint &cursorPos, const QDateTime &triggerTime)
 {
     // we check whether either the timer has explicitly been invalidated (successful trigger) or is
     // bigger than the reactivation threshold (activation "aborted", usually due to moving away the cursor
     // from the corner after successful activation)
     // either condition means that "this is the first event in a new attempt"
     if (!m_lastReset.isValid() || m_lastReset.msecsTo(triggerTime) > edges()->reActivationThreshold()) {
         m_lastReset = triggerTime;
         return false;
     }
     if (m_lastTrigger.isValid() && m_lastTrigger.msecsTo(triggerTime) < edges()->reActivationThreshold() - edges()->timeThreshold()) {
         return false;
     }
     if (m_lastReset.msecsTo(triggerTime) < edges()->timeThreshold()) {
         return false;
     }
     // does the check on position make any sense at all?
     if ((cursorPos - m_triggeredPoint).manhattanLength() > DISTANCE_RESET) {
         return false;
     }
     return true;
 }
 
 void Edge::handle(const QPoint &cursorPos)
 {
     AbstractClient *movingClient = Workspace::self()->moveResizeClient();
     if ((edges()->isDesktopSwitchingMovingClients() && movingClient && !movingClient->isResize()) ||
         (edges()->isDesktopSwitching() && isScreenEdge())) {
         // always switch desktops in case:
         // moving a Client and option for switch on client move is enabled
         // or switch on screen edge is enabled
         switchDesktop(cursorPos);
         return;
     }
     if (movingClient) {
         // if we are moving a window we don't want to trigger the actions. This just results in
         // problems, e.g. Desktop Grid activated or screen locker activated which just cannot
         // work as we hold a grab.
         return;
     }
 
     if (m_client) {
         pushCursorBack(cursorPos);
         m_client->showOnScreenEdge();
         unreserve();
         return;
     }
 
     if (handlePointerAction() || handleByCallback()) {
         pushCursorBack(cursorPos);
         return;
     }
     if (edges()->isDesktopSwitching() && isCorner()) {
         // try again desktop switching for the corner
         switchDesktop(cursorPos);
     }
 }
 
 bool Edge::handleAction(ElectricBorderAction action)
 {
     switch (action) {
     case ElectricActionShowDesktop: {
         Workspace::self()->setShowingDesktop(!Workspace::self()->showingDesktop());
         return true;
     }
     case ElectricActionLockScreen: { // Lock the screen
         OrgFreedesktopScreenSaverInterface interface(QStringLiteral("org.freedesktop.ScreenSaver"),
                                                      QStringLiteral("/ScreenSaver"),
                                                      QDBusConnection::sessionBus());
         if (interface.isValid()) {
             interface.Lock();
         }
         return true;
     }
     case ElectricActionKRunner: { // open krunner
         QDBusConnection::sessionBus().asyncCall(
             QDBusMessage::createMethodCall(QStringLiteral("org.kde.krunner"),
                                            QStringLiteral("/App"),
                                            QStringLiteral("org.kde.krunner.App"),
                                            QStringLiteral("display")
             )
         );
         return true;
     }
     case ElectricActionActivityManager: { // open activity manager
         QDBusConnection::sessionBus().asyncCall(
             QDBusMessage::createMethodCall(QStringLiteral("org.kde.plasmashell"),
                                            QStringLiteral("/PlasmaShell"),
                                            QStringLiteral("org.kde.PlasmaShell"),
                                            QStringLiteral("toggleActivityManager")
             )
         );
         return true;
     }
     case ElectricActionApplicationLauncher: {
         QDBusConnection::sessionBus().asyncCall(
             QDBusMessage::createMethodCall(QStringLiteral("org.kde.plasmashell"),
                                            QStringLiteral("/PlasmaShell"),
                                            QStringLiteral("org.kde.PlasmaShell"),
                                            QStringLiteral("activateLauncherMenu")
             )
         );
         return true;
     }
     default:
         return false;
     }
 }
 
 bool Edge::handleByCallback()
 {
     if (m_callBacks.isEmpty()) {
         return false;
     }
     for (QHash<QObject *, QByteArray>::iterator it = m_callBacks.begin();
         it != m_callBacks.end();
         ++it) {
         bool retVal = false;
         QMetaObject::invokeMethod(it.key(), it.value().constData(), Q_RETURN_ARG(bool, retVal), Q_ARG(ElectricBorder, m_border));
         if (retVal) {
             return true;
         }
     }
     return false;
 }
 
 void Edge::handleTouchCallback()
 {
     if (m_touchActions.isEmpty()) {
         return;
     }
     m_touchActions.first()->trigger();
 }
 
 void Edge::switchDesktop(const QPoint &cursorPos)
 {
     QPoint pos(cursorPos);
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     const uint oldDesktop = vds->current();
     uint desktop = oldDesktop;
     const int OFFSET = 2;
     if (isLeft()) {
         const uint interimDesktop = desktop;
         desktop = vds->toLeft(desktop, vds->isNavigationWrappingAround());
         if (desktop != interimDesktop)
             pos.setX(screens()->size().width() - 1 - OFFSET);
     } else if (isRight()) {
         const uint interimDesktop = desktop;
         desktop = vds->toRight(desktop, vds->isNavigationWrappingAround());
         if (desktop != interimDesktop)
             pos.setX(OFFSET);
     }
     if (isTop()) {
         const uint interimDesktop = desktop;
         desktop = vds->above(desktop, vds->isNavigationWrappingAround());
         if (desktop != interimDesktop)
             pos.setY(screens()->size().height() - 1 - OFFSET);
     } else if (isBottom()) {
         const uint interimDesktop = desktop;
         desktop = vds->below(desktop, vds->isNavigationWrappingAround());
         if (desktop != interimDesktop)
             pos.setY(OFFSET);
     }
 #ifndef KWIN_UNIT_TEST
     if (AbstractClient *c = Workspace::self()->moveResizeClient()) {
         if (c->rules()->checkDesktop(desktop) != int(desktop)) {
             // user attempts to move a client to another desktop where it is ruleforced to not be
             return;
         }
     }
 #endif
     vds->setCurrent(desktop);
     if (vds->current() != oldDesktop) {
         m_pushBackBlocked = true;
         Cursor::setPos(pos);
         QSharedPointer<QMetaObject::Connection> me(new QMetaObject::Connection);
         *me = QObject::connect(QCoreApplication::eventDispatcher(),
                                &QAbstractEventDispatcher::aboutToBlock, this,
                                [this, me](){
             QObject::disconnect(*me);
             const_cast<QSharedPointer<QMetaObject::Connection>*>(&me)->reset(nullptr);
             m_pushBackBlocked = false;
         }
         );
     }
 }
 
 void Edge::pushCursorBack(const QPoint &cursorPos)
 {
     if (m_pushBackBlocked)
         return;
     int x = cursorPos.x();
     int y = cursorPos.y();
     const QSize &distance = edges()->cursorPushBackDistance();
     if (isLeft()) {
         x += distance.width();
     }
     if (isRight()) {
         x -= distance.width();
     }
     if (isTop()) {
         y += distance.height();
     }
     if (isBottom()) {
         y -= distance.height();
     }
     Cursor::setPos(x, y);
 }
 
 void Edge::setGeometry(const QRect &geometry)
 {
     if (m_geometry == geometry) {
         return;
     }
     m_geometry = geometry;
     int x = m_geometry.x();
     int y = m_geometry.y();
     int width = m_geometry.width();
     int height = m_geometry.height();
     const int size = m_edges->cornerOffset();
     if (isCorner()) {
         if (isRight()) {
             x = x - size +1;
         }
         if (isBottom()) {
             y = y - size +1;
         }
         width = size;
         height = size;
     } else {
         if (isLeft()) {
             y += size + 1;
             width = size;
             height = height - size * 2;
         } else if (isRight()) {
             x = x - size + 1;
             y += size;
             width = size;
             height = height - size * 2;
         } else if (isTop()) {
             x += size;
             width = width - size * 2;
             height = size;
         } else if (isBottom()) {
             x += size;
             y = y - size +1;
             width = width - size * 2;
             height = size;
         }
     }
     m_approachGeometry = QRect(x, y, width, height);
     doGeometryUpdate();
 
     if (isScreenEdge()) {
         m_gesture->setStartGeometry(m_geometry);
         m_gesture->setMinimumDelta(screens()->size(screens()->number(m_geometry.center())) * 0.2);
     }
 }
 
 void Edge::checkBlocking()
 {
     if (isCorner()) {
         return;
     }
     bool newValue = false;
     if (AbstractClient *client = Workspace::self()->activeClient()) {
         newValue = client->isFullScreen() && client->frameGeometry().contains(m_geometry.center());
     }
     if (newValue == m_blocked) {
         return;
     }
     const bool wasTouch = activatesForTouchGesture();
     m_blocked = newValue;
     if (wasTouch != activatesForTouchGesture()) {
         emit activatesForTouchGestureChanged();
     }
     doUpdateBlocking();
 }
 
 void Edge::doUpdateBlocking()
 {
 }
 
 void Edge::doGeometryUpdate()
 {
 }
 
 void Edge::activate()
 {
     if (activatesForTouchGesture()) {
         m_edges->gestureRecognizer()->registerGesture(m_gesture);
     }
     doActivate();
 }
 
 void Edge::doActivate()
 {
 }
 
 void Edge::deactivate()
 {
     m_edges->gestureRecognizer()->unregisterGesture(m_gesture);
     doDeactivate();
 }
 
 void Edge::doDeactivate()
 {
 }
 
 void Edge::startApproaching()
 {
     if (m_approaching) {
         return;
     }
     m_approaching = true;
     doStartApproaching();
     m_lastApproachingFactor = 0;
     emit approaching(border(), 0.0, m_approachGeometry);
 }
 
 void Edge::doStartApproaching()
 {
 }
 
 void Edge::stopApproaching()
 {
     if (!m_approaching) {
         return;
     }
     m_approaching = false;
     doStopApproaching();
     m_lastApproachingFactor = 0;
     emit approaching(border(), 0.0, m_approachGeometry);
 }
 
 void Edge::doStopApproaching()
 {
 }
 
 void Edge::updateApproaching(const QPoint &point)
 {
     if (approachGeometry().contains(point)) {
         int factor = 0;
         const int edgeDistance = m_edges->cornerOffset();
         auto cornerDistance = [=](const QPoint &corner) {
             return qMax(qAbs(corner.x() - point.x()), qAbs(corner.y() - point.y()));
         };
         switch (border()) {
         case ElectricTopLeft:
             factor = (cornerDistance(approachGeometry().topLeft())<<8) / edgeDistance;
             break;
         case ElectricTopRight:
             factor = (cornerDistance(approachGeometry().topRight())<<8) / edgeDistance;
             break;
         case ElectricBottomRight:
             factor = (cornerDistance(approachGeometry().bottomRight())<<8) / edgeDistance;
             break;
         case ElectricBottomLeft:
             factor = (cornerDistance(approachGeometry().bottomLeft())<<8) / edgeDistance;
             break;
         case ElectricTop:
             factor = (qAbs(point.y() - approachGeometry().y())<<8) / edgeDistance;
             break;
         case ElectricRight:
             factor = (qAbs(point.x() - approachGeometry().right())<<8) / edgeDistance;
             break;
         case ElectricBottom:
             factor = (qAbs(point.y() - approachGeometry().bottom())<<8) / edgeDistance;
             break;
         case ElectricLeft:
             factor = (qAbs(point.x() - approachGeometry().x())<<8) / edgeDistance;
             break;
         default:
             break;
         }
         factor = 256 - factor;
         if (m_lastApproachingFactor != factor) {
             m_lastApproachingFactor = factor;
             emit approaching(border(), m_lastApproachingFactor/256.0f, m_approachGeometry);
         }
     } else {
         stopApproaching();
     }
 }
 
 quint32 Edge::window() const
 {
     return 0;
 }
 
 quint32 Edge::approachWindow() const
 {
     return 0;
 }
 
 void Edge::setBorder(ElectricBorder border)
 {
     m_border = border;
     switch (m_border) {
     case ElectricTop:
         m_gesture->setDirection(SwipeGesture::Direction::Down);
         break;
     case ElectricRight:
         m_gesture->setDirection(SwipeGesture::Direction::Left);
         break;
     case ElectricBottom:
         m_gesture->setDirection(SwipeGesture::Direction::Up);
         break;
     case ElectricLeft:
         m_gesture->setDirection(SwipeGesture::Direction::Right);
         break;
     default:
         break;
     }
 }
 
 void Edge::setTouchAction(ElectricBorderAction action) {
     const bool wasTouch = activatesForTouchGesture();
     m_touchAction = action;
     if (wasTouch != activatesForTouchGesture()) {
         emit activatesForTouchGestureChanged();
     }
 }
 
 void Edge::setClient(AbstractClient *client)
 {
     const bool wasTouch = activatesForTouchGesture();
     m_client = client;
     if (wasTouch != activatesForTouchGesture()) {
         emit activatesForTouchGestureChanged();
     }
 }
 
 /**********************************************************
  * ScreenEdges
  *********************************************************/
 KWIN_SINGLETON_FACTORY(ScreenEdges)
 
 ScreenEdges::ScreenEdges(QObject *parent)
     : QObject(parent)
     , m_desktopSwitching(false)
     , m_desktopSwitchingMovingClients(false)
     , m_timeThreshold(0)
     , m_reactivateThreshold(0)
     , m_virtualDesktopLayout({})
     , m_actionTopLeft(ElectricActionNone)
     , m_actionTop(ElectricActionNone)
     , m_actionTopRight(ElectricActionNone)
     , m_actionRight(ElectricActionNone)
     , m_actionBottomRight(ElectricActionNone)
     , m_actionBottom(ElectricActionNone)
     , m_actionBottomLeft(ElectricActionNone)
     , m_actionLeft(ElectricActionNone)
     , m_gestureRecognizer(new GestureRecognizer(this))
 {
-    QWidget w;
-    m_cornerOffset = (w.physicalDpiX() + w.physicalDpiY() + 5) / 6;
+    m_cornerOffset = (Screens::self()->physicalDpiX(0) + Screens::self()->physicalDpiX(0) + 5) / 6;
 
     connect(workspace(), &Workspace::clientRemoved, this, &ScreenEdges::deleteEdgeForClient);
 }
 
 ScreenEdges::~ScreenEdges()
 {
     s_self = nullptr;
 }
 
 void ScreenEdges::init()
 {
     reconfigure();
     updateLayout();
     recreateEdges();
 }
 static ElectricBorderAction electricBorderAction(const QString& name)
 {
     QString lowerName = name.toLower();
     if (lowerName == QStringLiteral("showdesktop")) {
         return ElectricActionShowDesktop;
     } else if (lowerName == QStringLiteral("lockscreen")) {
         return ElectricActionLockScreen;
     } else if (lowerName == QLatin1String("krunner")) {
         return ElectricActionKRunner;
     } else if (lowerName == QLatin1String("activitymanager")) {
         return ElectricActionActivityManager;
     } else if (lowerName == QLatin1String("applicationlauncher")) {
         return ElectricActionApplicationLauncher;
     }
     return ElectricActionNone;
 }
 
 void ScreenEdges::reconfigure()
 {
     if (!m_config) {
         return;
     }
     // TODO: migrate settings to a group ScreenEdges
     KConfigGroup windowsConfig = m_config->group("Windows");
     setTimeThreshold(windowsConfig.readEntry("ElectricBorderDelay", 150));
     setReActivationThreshold(qMax(timeThreshold() + 50, windowsConfig.readEntry("ElectricBorderCooldown", 350)));
     int desktopSwitching = windowsConfig.readEntry("ElectricBorders", static_cast<int>(ElectricDisabled));
     if (desktopSwitching == ElectricDisabled) {
         setDesktopSwitching(false);
         setDesktopSwitchingMovingClients(false);
     } else if (desktopSwitching == ElectricMoveOnly) {
         setDesktopSwitching(false);
         setDesktopSwitchingMovingClients(true);
     } else if (desktopSwitching == ElectricAlways) {
         setDesktopSwitching(true);
         setDesktopSwitchingMovingClients(true);
     }
     const int pushBack = windowsConfig.readEntry("ElectricBorderPushbackPixels", 1);
     m_cursorPushBackDistance = QSize(pushBack, pushBack);
 
     KConfigGroup borderConfig = m_config->group("ElectricBorders");
     setActionForBorder(ElectricTopLeft,     &m_actionTopLeft,
                        electricBorderAction(borderConfig.readEntry("TopLeft", "None")));
     setActionForBorder(ElectricTop,         &m_actionTop,
                        electricBorderAction(borderConfig.readEntry("Top", "None")));
     setActionForBorder(ElectricTopRight,    &m_actionTopRight,
                        electricBorderAction(borderConfig.readEntry("TopRight", "None")));
     setActionForBorder(ElectricRight,       &m_actionRight,
                        electricBorderAction(borderConfig.readEntry("Right", "None")));
     setActionForBorder(ElectricBottomRight, &m_actionBottomRight,
                        electricBorderAction(borderConfig.readEntry("BottomRight", "None")));
     setActionForBorder(ElectricBottom,      &m_actionBottom,
                        electricBorderAction(borderConfig.readEntry("Bottom", "None")));
     setActionForBorder(ElectricBottomLeft,  &m_actionBottomLeft,
                        electricBorderAction(borderConfig.readEntry("BottomLeft", "None")));
     setActionForBorder(ElectricLeft,        &m_actionLeft,
                        electricBorderAction(borderConfig.readEntry("Left", "None")));
 
     borderConfig = m_config->group("TouchEdges");
     setActionForTouchBorder(ElectricTop, electricBorderAction(borderConfig.readEntry("Top", "None")));
     setActionForTouchBorder(ElectricRight, electricBorderAction(borderConfig.readEntry("Right", "None")));
     setActionForTouchBorder(ElectricBottom, electricBorderAction(borderConfig.readEntry("Bottom", "None")));
     setActionForTouchBorder(ElectricLeft, electricBorderAction(borderConfig.readEntry("Left", "None")));
 }
 
 void ScreenEdges::setActionForBorder(ElectricBorder border, ElectricBorderAction *oldValue, ElectricBorderAction newValue)
 {
     if (*oldValue == newValue) {
         return;
     }
     if (*oldValue == ElectricActionNone) {
         // have to reserve
         for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
             if ((*it)->border() == border) {
                 (*it)->reserve();
             }
         }
     }
     if (newValue == ElectricActionNone) {
         // have to unreserve
         for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
             if ((*it)->border() == border) {
                 (*it)->unreserve();
             }
         }
     }
     *oldValue = newValue;
     // update action on all Edges for given border
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->setAction(newValue);
         }
     }
 }
 
 void ScreenEdges::setActionForTouchBorder(ElectricBorder border, ElectricBorderAction newValue)
 {
     auto it = m_touchActions.find(border);
     ElectricBorderAction oldValue = ElectricActionNone;
     if (it != m_touchActions.end()) {
         oldValue = it.value();
     }
     if (oldValue == newValue) {
         return;
     }
     if (oldValue == ElectricActionNone) {
         // have to reserve
         for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
             if ((*it)->border() == border) {
                 (*it)->reserve();
             }
         }
     }
     if (newValue == ElectricActionNone) {
         // have to unreserve
         for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
             if ((*it)->border() == border) {
                 (*it)->unreserve();
             }
         }
 
         m_touchActions.erase(it);
     } else {
         m_touchActions.insert(border, newValue);
     }
     // update action on all Edges for given border
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->setTouchAction(newValue);
         }
     }
 }
 
 void ScreenEdges::updateLayout()
 {
     const QSize desktopMatrix = VirtualDesktopManager::self()->grid().size();
     Qt::Orientations newLayout = {};
     if (desktopMatrix.width() > 1) {
         newLayout |= Qt::Horizontal;
     }
     if (desktopMatrix.height() > 1) {
         newLayout |= Qt::Vertical;
     }
     if (newLayout == m_virtualDesktopLayout) {
         return;
     }
     if (isDesktopSwitching()) {
         reserveDesktopSwitching(false, m_virtualDesktopLayout);
     }
     m_virtualDesktopLayout = newLayout;
     if (isDesktopSwitching()) {
         reserveDesktopSwitching(true, m_virtualDesktopLayout);
     }
 }
 
 static bool isLeftScreen(const QRect &screen, const QRect &fullArea)
 {
     if (screens()->count() == 1) {
         return true;
     }
     if (screen.x() == fullArea.x()) {
         return true;
     }
     // the screen is also on the left in case of a vertical layout with a second screen
     // more to the left. In that case no screen ends left of screen's x coord
     for (int i=0; i<screens()->count(); ++i) {
         const QRect otherGeo = screens()->geometry(i);
         if (otherGeo == screen) {
             // that's our screen to test
             continue;
         }
         if (otherGeo.x() + otherGeo.width() <= screen.x()) {
             // other screen is completely in the left
             return false;
         }
     }
     // did not find a screen left of our current screen, so it is the left most
     return true;
 }
 
 static bool isRightScreen(const QRect &screen, const QRect &fullArea)
 {
     if (screens()->count() == 1) {
         return true;
     }
     if (screen.x() + screen.width() == fullArea.x() + fullArea.width()) {
         return true;
     }
     // the screen is also on the right in case of a vertical layout with a second screen
     // more to the right. In that case no screen starts right of this screen
     for (int i=0; i<screens()->count(); ++i) {
         const QRect otherGeo = screens()->geometry(i);
         if (otherGeo == screen) {
             // that's our screen to test
             continue;
         }
         if (otherGeo.x() >= screen.x() + screen.width()) {
             // other screen is completely in the right
             return false;
         }
     }
     // did not find a screen right of our current screen, so it is the right most
     return true;
 }
 
 static bool isTopScreen(const QRect &screen, const QRect &fullArea)
 {
     if (screens()->count() == 1) {
         return true;
     }
     if (screen.y() == fullArea.y()) {
         return true;
     }
     // the screen is also top most in case of a horizontal layout with a second screen
     // more to the top. In that case no screen ends above screen's y coord
     for (int i=0; i<screens()->count(); ++i) {
         const QRect otherGeo = screens()->geometry(i);
         if (otherGeo == screen) {
             // that's our screen to test
             continue;
         }
         if (otherGeo.y() + otherGeo.height() <= screen.y()) {
             // other screen is completely above
             return false;
         }
     }
     // did not find a screen above our current screen, so it is the top most
     return true;
 }
 
 static bool isBottomScreen(const QRect &screen, const QRect &fullArea)
 {
     if (screens()->count() == 1) {
         return true;
     }
     if (screen.y() + screen.height() == fullArea.y() + fullArea.height()) {
         return true;
     }
     // the screen is also bottom most in case of a horizontal layout with a second screen
     // more below. In that case no screen starts below screen's y coord + height
     for (int i=0; i<screens()->count(); ++i) {
         const QRect otherGeo = screens()->geometry(i);
         if (otherGeo == screen) {
             // that's our screen to test
             continue;
         }
         if (otherGeo.y() >= screen.y() + screen.height()) {
             // other screen is completely below
             return false;
         }
     }
     // did not find a screen below our current screen, so it is the bottom most
     return true;
 }
 
 void ScreenEdges::recreateEdges()
 {
     QList<Edge*> oldEdges(m_edges);
     m_edges.clear();
     const QRect fullArea = screens()->geometry();
     QRegion processedRegion;
     for (int i=0; i<screens()->count(); ++i) {
         const QRegion screen = QRegion(screens()->geometry(i)).subtracted(processedRegion);
         processedRegion += screen;
         for (const QRect &screenPart : screen) {
             if (isLeftScreen(screenPart, fullArea)) {
                 // left most screen
                 createVerticalEdge(ElectricLeft, screenPart, fullArea);
             }
             if (isRightScreen(screenPart, fullArea)) {
                 // right most screen
                 createVerticalEdge(ElectricRight, screenPart, fullArea);
             }
             if (isTopScreen(screenPart, fullArea)) {
                 // top most screen
                 createHorizontalEdge(ElectricTop, screenPart, fullArea);
             }
             if (isBottomScreen(screenPart, fullArea)) {
                 // bottom most screen
                 createHorizontalEdge(ElectricBottom, screenPart, fullArea);
             }
         }
     }
     // copy over the effect/script reservations from the old edges
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         Edge *edge = *it;
         for (auto oldIt = oldEdges.constBegin();
                 oldIt != oldEdges.constEnd();
                 ++oldIt) {
             Edge *oldEdge = *oldIt;
             if (oldEdge->client()) {
                 // show the client again and don't recreate the edge
                 oldEdge->client()->showOnScreenEdge();
                 continue;
             }
             if (oldEdge->border() != edge->border()) {
                 continue;
             }
             const QHash<QObject *, QByteArray> &callbacks = oldEdge->callBacks();
             for (QHash<QObject *, QByteArray>::const_iterator callback = callbacks.begin();
                     callback != callbacks.end();
                     ++callback) {
                 edge->reserve(callback.key(), callback.value().constData());
             }
             const auto touchCallBacks = oldEdge->touchCallBacks();
             for (auto a : touchCallBacks) {
                 edge->reserveTouchCallBack(a);
             }
         }
     }
     qDeleteAll(oldEdges);
 }
 
 void ScreenEdges::createVerticalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea)
 {
     if (border != ElectricRight && border != KWin::ElectricLeft) {
         return;
     }
     int y = screen.y();
     int height = screen.height();
     const int x = (border == ElectricLeft) ? screen.x() : screen.x() + screen.width() -1;
     if (isTopScreen(screen, fullArea)) {
         // also top most screen
         height -= m_cornerOffset;
         y += m_cornerOffset;
         // create top left/right edge
         const ElectricBorder edge = (border == ElectricLeft) ? ElectricTopLeft : ElectricTopRight;
         m_edges << createEdge(edge, x, screen.y(), 1, 1);
     }
     if (isBottomScreen(screen, fullArea)) {
         // also bottom most screen
         height -= m_cornerOffset;
         // create bottom left/right edge
         const ElectricBorder edge = (border == ElectricLeft) ? ElectricBottomLeft : ElectricBottomRight;
         m_edges << createEdge(edge, x, screen.y() + screen.height() -1, 1, 1);
     }
     // create border
     m_edges << createEdge(border, x, y, 1, height);
 }
 
 void ScreenEdges::createHorizontalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea)
 {
     if (border != ElectricTop && border != ElectricBottom) {
         return;
     }
     int x = screen.x();
     int width = screen.width();
     if (isLeftScreen(screen, fullArea)) {
         // also left most - adjust only x and width
         x += m_cornerOffset;
         width -= m_cornerOffset;
     }
     if (isRightScreen(screen, fullArea)) {
         // also right most edge
         width -= m_cornerOffset;
     }
     const int y = (border == ElectricTop) ? screen.y() : screen.y() + screen.height() - 1;
     m_edges << createEdge(border, x, y, width, 1);
 }
 
 Edge *ScreenEdges::createEdge(ElectricBorder border, int x, int y, int width, int height, bool createAction)
 {
 #ifdef KWIN_UNIT_TEST
     Edge *edge = new WindowBasedEdge(this);
 #else
     Edge *edge = kwinApp()->platform()->createScreenEdge(this);
 #endif
     edge->setBorder(border);
     edge->setGeometry(QRect(x, y, width, height));
     if (createAction) {
         const ElectricBorderAction action = actionForEdge(edge);
         if (action != KWin::ElectricActionNone) {
             edge->reserve();
             edge->setAction(action);
         }
         const ElectricBorderAction touchAction = actionForTouchEdge(edge);
         if (touchAction != KWin::ElectricActionNone) {
             edge->reserve();
             edge->setTouchAction(touchAction);
         }
     }
     if (isDesktopSwitching()) {
         if (edge->isCorner()) {
             edge->reserve();
         } else {
             if ((m_virtualDesktopLayout & Qt::Horizontal) && (edge->isLeft() || edge->isRight())) {
                 edge->reserve();
             }
             if ((m_virtualDesktopLayout & Qt::Vertical) && (edge->isTop() || edge->isBottom())) {
                 edge->reserve();
             }
         }
     }
     connect(edge, SIGNAL(approaching(ElectricBorder,qreal,QRect)), SIGNAL(approaching(ElectricBorder,qreal,QRect)));
     if (edge->isScreenEdge()) {
         connect(this, SIGNAL(checkBlocking()), edge, SLOT(checkBlocking()));
     }
     return edge;
 }
 
 ElectricBorderAction ScreenEdges::actionForEdge(Edge *edge) const
 {
     switch (edge->border()) {
     case ElectricTopLeft:
         return m_actionTopLeft;
     case ElectricTop:
         return m_actionTop;
     case ElectricTopRight:
         return m_actionTopRight;
     case ElectricRight:
         return m_actionRight;
     case ElectricBottomRight:
         return m_actionBottomRight;
     case ElectricBottom:
         return m_actionBottom;
     case ElectricBottomLeft:
         return m_actionBottomLeft;
     case ElectricLeft:
         return m_actionLeft;
     default:
         // fall through
         break;
     }
     return ElectricActionNone;
 }
 
 ElectricBorderAction ScreenEdges::actionForTouchEdge(Edge *edge) const
 {
     auto it = m_touchActions.find(edge->border());
     if (it != m_touchActions.end()) {
         return it.value();
     }
     return ElectricActionNone;
 }
 
 void ScreenEdges::reserveDesktopSwitching(bool isToReserve, Qt::Orientations o)
 {
     if (!o)
         return;
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         Edge *edge = *it;
         if (edge->isCorner()) {
             isToReserve ? edge->reserve() : edge->unreserve();
         } else {
             if ((m_virtualDesktopLayout & Qt::Horizontal) && (edge->isLeft() || edge->isRight())) {
                 isToReserve ? edge->reserve() : edge->unreserve();
             }
             if ((m_virtualDesktopLayout & Qt::Vertical) && (edge->isTop() || edge->isBottom())) {
                 isToReserve ? edge->reserve() : edge->unreserve();
             }
         }
     }
 }
 
 void ScreenEdges::reserve(ElectricBorder border, QObject *object, const char *slot)
 {
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->reserve(object, slot);
         }
     }
 }
 
 void ScreenEdges::unreserve(ElectricBorder border, QObject *object)
 {
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->unreserve(object);
         }
     }
 }
 
 void ScreenEdges::reserve(AbstractClient *client, ElectricBorder border)
 {
     bool hadBorder = false;
     auto it = m_edges.begin();
     while (it != m_edges.end()) {
         if ((*it)->client() == client) {
             hadBorder = true;
             delete *it;
             it = m_edges.erase(it);
         } else {
             it++;
         }
     }
 
     if (border != ElectricNone) {
         createEdgeForClient(client, border);
     } else {
         if (hadBorder) // show again
             client->showOnScreenEdge();
     }
 }
 
 void ScreenEdges::reserveTouch(ElectricBorder border, QAction *action)
 {
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->reserveTouchCallBack(action);
         }
     }
 }
 
 void ScreenEdges::unreserveTouch(ElectricBorder border, QAction *action)
 {
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if ((*it)->border() == border) {
             (*it)->unreserveTouchCallBack(action);
         }
     }
 }
 
 void ScreenEdges::createEdgeForClient(AbstractClient *client, ElectricBorder border)
 {
     int y = 0;
     int x = 0;
     int width = 0;
     int height = 0;
     const QRect geo = client->frameGeometry();
     const QRect fullArea = workspace()->clientArea(FullArea, 0, 1);
     for (int i = 0; i < screens()->count(); ++i) {
         const QRect screen = screens()->geometry(i);
         if (!screen.contains(geo)) {
             // ignoring Clients having a geometry overlapping with multiple screens
             // this would make the code more complex. If it's needed in future it can be added
             continue;
         }
         const bool bordersTop = (screen.y() == geo.y());
         const bool bordersLeft = (screen.x() == geo.x());
         const bool bordersBottom = (screen.y() + screen.height() == geo.y() + geo.height());
         const bool bordersRight = (screen.x() + screen.width() == geo.x() + geo.width());
 
         if (bordersTop && border == ElectricTop) {
             if (!isTopScreen(screen, fullArea)) {
                 continue;
             }
             y = geo.y();
             x = geo.x();
             height = 1;
             width = geo.width();
             break;
         }
         if (bordersBottom && border == ElectricBottom) {
             if (!isBottomScreen(screen, fullArea)) {
                 continue;
             }
             y = geo.y() + geo.height() - 1;
             x = geo.x();
             height = 1;
             width = geo.width();
             break;
         }
         if (bordersLeft && border == ElectricLeft) {
             if (!isLeftScreen(screen, fullArea)) {
                 continue;
             }
             x = geo.x();
             y = geo.y();
             width = 1;
             height = geo.height();
             break;
         }
         if (bordersRight && border == ElectricRight) {
             if (!isRightScreen(screen, fullArea)) {
                 continue;
             }
             x = geo.x() + geo.width() - 1;
             y = geo.y();
             width = 1;
             height = geo.height();
             break;
         }
     }
 
     if (width > 0 && height > 0) {
         Edge *edge = createEdge(border, x, y, width, height, false);
         edge->setClient(client);
         m_edges.append(edge);
         edge->reserve();
     } else {
         // we could not create an edge window, so don't allow the window to hide
         client->showOnScreenEdge();
     }
 }
 
 void ScreenEdges::deleteEdgeForClient(AbstractClient* c)
 {
     auto it = m_edges.begin();
     while (it != m_edges.end()) {
         if ((*it)->client() == c) {
             delete *it;
             it = m_edges.erase(it);
         } else {
             it++;
         }
     }
 }
 
 void ScreenEdges::check(const QPoint &pos, const QDateTime &now, bool forceNoPushBack)
 {
     bool activatedForClient = false;
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         if (!(*it)->isReserved()) {
             continue;
         }
         if (!(*it)->activatesForPointer()) {
             continue;
         }
         if ((*it)->approachGeometry().contains(pos)) {
             (*it)->startApproaching();
         }
         if ((*it)->client() != nullptr && activatedForClient) {
             (*it)->markAsTriggered(pos, now);
             continue;
         }
         if ((*it)->check(pos, now, forceNoPushBack)) {
             if ((*it)->client()) {
                 activatedForClient = true;
             }
         }
     }
 }
 
 bool ScreenEdges::isEntered(QMouseEvent *event)
 {
     if (event->type() != QEvent::MouseMove) {
         return false;
     }
     bool activated = false;
     bool activatedForClient = false;
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         Edge *edge = *it;
         if (!edge->isReserved()) {
             continue;
         }
         if (!edge->activatesForPointer()) {
             continue;
         }
         if (edge->approachGeometry().contains(event->globalPos())) {
             if (!edge->isApproaching()) {
                 edge->startApproaching();
             } else {
                 edge->updateApproaching(event->globalPos());
             }
         } else {
             if (edge->isApproaching()) {
                 edge->stopApproaching();
             }
         }
         if (edge->geometry().contains(event->globalPos())) {
             if (edge->check(event->globalPos(), QDateTime::fromMSecsSinceEpoch(event->timestamp(), Qt::UTC))) {
                 if (edge->client()) {
                     activatedForClient = true;
                 }
             }
         }
     }
     if (activatedForClient) {
         for (auto it = m_edges.constBegin(); it != m_edges.constEnd(); ++it) {
             if ((*it)->client()) {
                 (*it)->markAsTriggered(event->globalPos(), QDateTime::fromMSecsSinceEpoch(event->timestamp(), Qt::UTC));
             }
         }
     }
     return activated;
 }
 
 bool ScreenEdges::handleEnterNotifiy(xcb_window_t window, const QPoint &point, const QDateTime &timestamp)
 {
     bool activated = false;
     bool activatedForClient = false;
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         Edge *edge = *it;
         if (!edge || edge->window() == XCB_WINDOW_NONE) {
             continue;
         }
         if (!edge->isReserved()) {
             continue;
         }
         if (!edge->activatesForPointer()) {
             continue;
         }
         if (edge->window() == window) {
             if (edge->check(point, timestamp)) {
                 if ((*it)->client()) {
                     activatedForClient = true;
                 }
             }
             activated = true;
             break;
         }
         if (edge->approachWindow() == window) {
             edge->startApproaching();
             // TODO: if it's a corner, it should also trigger for other windows
             return true;
         }
     }
     if (activatedForClient) {
         for (auto it = m_edges.constBegin(); it != m_edges.constEnd(); ++it) {
             if ((*it)->client()) {
                 (*it)->markAsTriggered(point, timestamp);
             }
         }
     }
     return activated;
 }
 
 bool ScreenEdges::handleDndNotify(xcb_window_t window, const QPoint &point)
 {
     for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
         Edge *edge = *it;
         if (!edge || edge->window() == XCB_WINDOW_NONE) {
             continue;
         }
         if (edge->isReserved() && edge->window() == window) {
             updateXTime();
             edge->check(point, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC), true);
             return true;
         }
     }
     return false;
 }
 
 void ScreenEdges::ensureOnTop()
 {
     Xcb::restackWindowsWithRaise(windows());
 }
 
 QVector< xcb_window_t > ScreenEdges::windows() const
 {
     QVector<xcb_window_t> wins;
     for (auto it = m_edges.constBegin();
             it != m_edges.constEnd();
             ++it) {
         Edge *edge = *it;
         xcb_window_t w = edge->window();
         if (w != XCB_WINDOW_NONE) {
             wins.append(w);
         }
         // TODO:  lambda
         w = edge->approachWindow();
         if (w != XCB_WINDOW_NONE) {
             wins.append(w);
         }
     }
     return wins;
 }
 
 } //namespace
diff --git a/screens.cpp b/screens.cpp
index a83870847..5dcb257a9 100644
--- a/screens.cpp
+++ b/screens.cpp
@@ -1,232 +1,242 @@
 /********************************************************************
  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 "screens.h"
 #include <abstract_client.h>
 #include <x11client.h>
 #include "cursor.h"
 #include "utils.h"
 #include "settings.h"
 #include <workspace.h>
 #include <config-kwin.h>
 #include "platform.h"
 #include "wayland_server.h"
 #ifdef KWIN_UNIT_TEST
 #include <mock_screens.h>
 #endif
 
 namespace KWin
 {
 
 Screens *Screens::s_self = nullptr;
 Screens *Screens::create(QObject *parent)
 {
     Q_ASSERT(!s_self);
 #ifdef KWIN_UNIT_TEST
     s_self = new MockScreens(parent);
 #else
     s_self = kwinApp()->platform()->createScreens(parent);
 #endif
     Q_ASSERT(s_self);
     s_self->init();
     return s_self;
 }
 
 Screens::Screens(QObject *parent)
     : QObject(parent)
     , m_count(0)
     , m_current(0)
     , m_currentFollowsMouse(false)
     , m_changedTimer(new QTimer(this))
     , m_maxScale(1.0)
 {
 }
 
 Screens::~Screens()
 {
     s_self = nullptr;
 }
 
 void Screens::init()
 {
     m_changedTimer->setSingleShot(true);
     m_changedTimer->setInterval(100);
     connect(m_changedTimer, SIGNAL(timeout()), SLOT(updateCount()));
     connect(m_changedTimer, SIGNAL(timeout()), SIGNAL(changed()));
     connect(this, &Screens::countChanged, this, &Screens::changed, Qt::QueuedConnection);
     connect(this, &Screens::changed, this, &Screens::updateSize);
     connect(this, &Screens::sizeChanged, this, &Screens::geometryChanged);
 
     Settings settings;
     settings.setDefaults();
     m_currentFollowsMouse = settings.activeMouseScreen();
 }
 
 QString Screens::name(int screen) const
 {
     Q_UNUSED(screen)
     qCWarning(KWIN_CORE, "%s::name(int screen) is a stub, please reimplement it!", metaObject()->className());
     return QLatin1String("DUMMY");
 }
 
 float Screens::refreshRate(int screen) const
 {
     Q_UNUSED(screen)
     qCWarning(KWIN_CORE, "%s::refreshRate(int screen) is a stub, please reimplement it!", metaObject()->className());
     return 60.0f;
 }
 
 qreal Screens::maxScale() const
 {
     return m_maxScale;
 }
 
 qreal Screens::scale(int screen) const
 {
     Q_UNUSED(screen)
     return 1;
 }
 
 void Screens::reconfigure()
 {
     if (!m_config) {
         return;
     }
     Settings settings(m_config);
     settings.read();
     setCurrentFollowsMouse(settings.activeMouseScreen());
 }
 
 void Screens::updateSize()
 {
     QRect bounding;
     qreal maxScale = 1.0;
     for (int i = 0; i < count(); ++i) {
         bounding = bounding.united(geometry(i));
         maxScale = qMax(maxScale, scale(i));
     }
     if (m_boundingSize != bounding.size()) {
         m_boundingSize = bounding.size();
         emit sizeChanged();
     }
     if (!qFuzzyCompare(m_maxScale, maxScale)) {
         m_maxScale = maxScale;
         emit maxScaleChanged();
     }
 }
 
 void Screens::setCount(int count)
 {
     if (m_count == count) {
         return;
     }
     const int previous = m_count;
     m_count = count;
     emit countChanged(previous, count);
 }
 
 void Screens::setCurrent(int current)
 {
     if (m_current == current) {
         return;
     }
     m_current = current;
     emit currentChanged();
 }
 
 void Screens::setCurrent(const QPoint &pos)
 {
     setCurrent(number(pos));
 }
 
 void Screens::setCurrent(const AbstractClient *c)
 {
     if (!c->isActive()) {
         return;
     }
     if (!c->isOnScreen(m_current)) {
         setCurrent(c->screen());
     }
 }
 
 void Screens::setCurrentFollowsMouse(bool follows)
 {
     if (m_currentFollowsMouse == follows) {
         return;
     }
     m_currentFollowsMouse = follows;
 }
 
 int Screens::current() const
 {
     if (m_currentFollowsMouse) {
         return number(Cursor::pos());
     }
     AbstractClient *client = Workspace::self()->activeClient();
     if (client && !client->isOnScreen(m_current)) {
         return client->screen();
     }
     return m_current;
 }
 
 int Screens::intersecting(const QRect &r) const
 {
     int cnt = 0;
     for (int i = 0; i < count(); ++i) {
         if (geometry(i).intersects(r)) {
             ++cnt;
         }
     }
     return cnt;
 }
 
 QSize Screens::displaySize() const
 {
     return size();
 }
 
 QSizeF Screens::physicalSize(int screen) const
 {
     return QSizeF(size(screen)) / 3.8;
 }
 
 bool Screens::isInternal(int screen) const
 {
     Q_UNUSED(screen)
     return false;
 }
 
 bool Screens::supportsTransformations(int screen) const
 {
     Q_UNUSED(screen)
     return false;
 }
 
 Qt::ScreenOrientation Screens::orientation(int screen) const
 {
     Q_UNUSED(screen)
     return Qt::PrimaryOrientation;
 }
 
 void Screens::setConfig(KSharedConfig::Ptr config)
 {
     m_config = config;
 }
 
+int Screens::physicalDpiX(int screen) const
+{
+    return size(screen).width() / physicalSize(screen).width() * qreal(25.4);
+}
+
+int Screens::physicalDpiY(int screen) const
+{
+    return size(screen).height() / physicalSize(screen).height() * qreal(25.4);
+}
+
 } // namespace
diff --git a/screens.h b/screens.h
index 33d7750c3..128110149 100644
--- a/screens.h
+++ b/screens.h
@@ -1,243 +1,246 @@
 /********************************************************************
  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_SCREENS_H
 #define KWIN_SCREENS_H
 
 // KWin includes
 #include <kwinglobals.h>
 // KDE includes
 #include <KConfig>
 #include <KSharedConfig>
 // Qt includes
 #include <QObject>
 #include <QRect>
 #include <QTimer>
 #include <QVector>
 
 namespace KWin
 {
 class AbstractClient;
 class Platform;
 
 class KWIN_EXPORT Screens : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)
     Q_PROPERTY(int current READ current WRITE setCurrent NOTIFY currentChanged)
     Q_PROPERTY(bool currentFollowsMouse READ isCurrentFollowsMouse WRITE setCurrentFollowsMouse)
 
 public:
     ~Screens() override;
     /**
      * @internal
      */
     void setConfig(KSharedConfig::Ptr config);
     int count() const;
     int current() const;
     void setCurrent(int current);
     /**
      * Called e.g. when a user clicks on a window, set current screen to be the screen
      * where the click occurred
      */
     void setCurrent(const QPoint &pos);
     /**
      * Check whether a client moved completely out of what's considered the current screen,
      * if yes, set a new active screen.
      */
     void setCurrent(const AbstractClient *c);
     bool isCurrentFollowsMouse() const;
     void setCurrentFollowsMouse(bool follows);
     virtual QRect geometry(int screen) const = 0;
     /**
      * The bounding geometry of all screens combined. Overlapping areas
      * are not counted multiple times.
      * @see geometryChanged()
      */
     QRect geometry() const;
     /**
      * The output name of the screen (usually eg. LVDS-1, VGA-0 or DVI-I-1 etc.)
      */
     virtual QString name(int screen) const;
     /**
      * @returns current refreshrate of the @p screen.
      */
     virtual float refreshRate(int screen) const;
     /**
      * @returns size of the @p screen.
      *
      * To get the size of all screens combined use size().
      * @see size()
      */
     virtual QSize size(int screen) const = 0;
 
     /**
      * The highest scale() of all connected screens
      * for use when deciding what scale to load global assets at
      * Similar to QGuiApplication::scale
      * @see scale
      */
     qreal maxScale() const;
 
     /**
      * The output scale for this display, for use by high DPI displays
      */
     virtual qreal scale(int screen) const;
     /**
      * The bounding size of all screens combined. Overlapping areas
      * are not counted multiple times.
      *
      * @see geometry()
      * @see sizeChanged()
      */
     QSize size() const;
     virtual int number(const QPoint &pos) const = 0;
 
     inline bool isChanging() { return m_changedTimer->isActive(); }
 
     int intersecting(const QRect &r) const;
 
     /**
      * The virtual bounding size of all screens combined.
      * The default implementation returns the same as @ref size and that is the
      * method which should be preferred.
      *
      * This method is only for cases where the platform specific implementation needs
      * to support different virtual sizes like on X11 with XRandR panning.
      *
      * @see size
      */
     virtual QSize displaySize() const;
 
 
     /**
      * The physical size of @p screen in mm.
      * Default implementation returns a size derived from 96 DPI.
      */
     virtual QSizeF physicalSize(int screen) const;
 
     /**
      * @returns @c true if the @p screen is connected through an internal display (e.g. LVDS).
      * Default implementation returns @c false.
      */
     virtual bool isInternal(int screen) const;
 
     /**
      * @returns @c true if the @p screen can be rotated.
      * Default implementation returns @c false
      */
     virtual bool supportsTransformations(int screen) const;
 
     virtual Qt::ScreenOrientation orientation(int screen) const;
 
+    int physicalDpiX(int screen) const;
+    int physicalDpiY(int screen) const;
+
 public Q_SLOTS:
     void reconfigure();
 
 Q_SIGNALS:
     void countChanged(int previousCount, int newCount);
     /**
      * Emitted whenever the screens are changed either count or geometry.
      */
     void changed();
     void currentChanged();
     /**
      * Emitted when the geometry of all screens combined changes.
      * Not emitted when the geometry of an individual screen changes.
      * @see geometry()
      */
     void geometryChanged();
     /**
      * Emitted when the size of all screens combined changes.
      * Not emitted when the size of an individual screen changes.
      * @see size()
      */
     void sizeChanged();
     /**
      * Emitted when the maximum scale of all attached screens changes
      * @see maxScale
      */
     void maxScaleChanged();
 
 protected Q_SLOTS:
     void setCount(int count);
     void startChangedTimer();
     virtual void updateCount() = 0;
 
 protected:
     /**
      * Called once the singleton instance has been created.
      * Any initialization code should go into this method. Overriding classes have to call
      * the base implementation first.
      */
     virtual void init();
 
 private Q_SLOTS:
     void updateSize();
 
 private:
     int m_count;
     int m_current;
     bool m_currentFollowsMouse;
     QTimer *m_changedTimer;
     KSharedConfig::Ptr m_config;
     QSize m_boundingSize;
     qreal m_maxScale;
 
     KWIN_SINGLETON(Screens)
 };
 
 inline
 int Screens::count() const
 {
     return m_count;
 }
 
 inline
 bool Screens::isCurrentFollowsMouse() const
 {
     return m_currentFollowsMouse;
 }
 
 inline
 void Screens::startChangedTimer()
 {
     m_changedTimer->start();
 }
 
 inline
 QSize Screens::size() const
 {
     return m_boundingSize;
 }
 
 inline
 QRect Screens::geometry() const
 {
     return QRect(QPoint(0,0), size());
 }
 
 inline
 Screens *screens()
 {
     return Screens::self();
 }
 
 }
 
 #endif // KWIN_SCREENS_H