diff --git a/kcm/src/declarative/qmloutput.cpp b/kcm/src/declarative/qmloutput.cpp
index e973247..61e8df1 100644
--- a/kcm/src/declarative/qmloutput.cpp
+++ b/kcm/src/declarative/qmloutput.cpp
@@ -1,585 +1,587 @@
 /*
     Copyright (C) 2012  Dan Vratil <dvratil@redhat.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 
 #include "qmloutput.h"
 #include "qmlscreen.h"
 
 #include <kscreen/output.h>
 
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <qquickitem.h>
 #include <QRect>
 
 const static int sMargin = 0;
 const static int sSnapArea = 20;
 const static int sSnapAlignArea = 6;
 
 Q_DECLARE_METATYPE(KScreen::ModePtr)
 
 bool operator>(const QSize &sizeA, const QSize &sizeB)
 {
     return ((sizeA.width() > sizeB.width()) && (sizeA.height() > sizeB.height()));
 }
 
 QMLOutput::QMLOutput(QQuickItem *parent):
     QQuickItem(parent),
     m_screen(0),
     m_cloneOf(0),
     m_leftDock(0),
     m_topDock(0),
     m_rightDock(0),
     m_bottomDock(0),
     m_isCloneMode(false)
 {
     connect(this, &QMLOutput::xChanged,
             this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
     connect(this, &QMLOutput::yChanged,
             this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
 }
 
 QMLOutput::~QMLOutput()
 {
 
 }
 
 KScreen::Output* QMLOutput::output() const
 {
     return m_output.data();
 }
 
 KScreen::OutputPtr QMLOutput::outputPtr() const
 {
     return m_output;
 }
 
 void QMLOutput::setOutputPtr(const KScreen::OutputPtr &output)
 {
     Q_ASSERT(m_output.isNull());
 
     m_output = output;
     Q_EMIT outputChanged();
 
     connect(m_output.data(), &KScreen::Output::rotationChanged,
             this, &QMLOutput::updateRootProperties);
     connect(m_output.data(), &KScreen::Output::currentModeIdChanged,
             this, &QMLOutput::currentModeIdChanged);
+    connect(m_output.data(), &KScreen::Output::scaleChanged,
+            this, &QMLOutput::currentModeIdChanged);
 }
 
 QMLScreen *QMLOutput::screen() const
 {
     return m_screen;
 }
 
 void QMLOutput::setScreen(QMLScreen *screen)
 {
     Q_ASSERT(m_screen == 0);
 
     m_screen = screen;
     Q_EMIT screenChanged();
 }
 
 void QMLOutput::setLeftDockedTo(QMLOutput *output)
 {
     if (m_leftDock == output) {
         return;
     }
 
     m_leftDock = output;
     Q_EMIT leftDockedToChanged();
 }
 
 QMLOutput *QMLOutput::leftDockedTo() const
 {
     return m_leftDock;
 }
 
 void QMLOutput::undockLeft()
 {
     setLeftDockedTo(0);
 }
 
 void QMLOutput::setTopDockedTo(QMLOutput *output)
 {
     if (m_topDock == output) {
         return;
     }
 
     m_topDock = output;
     Q_EMIT topDockedToChanged();
 }
 
 QMLOutput *QMLOutput::topDockedTo() const
 {
     return m_topDock;
 }
 
 void QMLOutput::undockTop()
 {
     setTopDockedTo(0);
 }
 
 void QMLOutput::setRightDockedTo(QMLOutput *output)
 {
     if (m_rightDock == output) {
         return;
     }
 
     m_rightDock = output;
     Q_EMIT rightDockedToChanged();
 }
 
 QMLOutput *QMLOutput::rightDockedTo() const
 {
     return m_rightDock;
 }
 
 void QMLOutput::undockRight()
 {
     setRightDockedTo(0);
 }
 
 void QMLOutput::setBottomDockedTo(QMLOutput *output)
 {
     if (m_bottomDock == output) {
         return;
     }
 
     m_bottomDock = output;
     Q_EMIT bottomDockedToChanged();
 }
 
 QMLOutput *QMLOutput::bottomDockedTo() const
 {
     return m_bottomDock;
 }
 
 void QMLOutput::undockBottom()
 {
     setBottomDockedTo(0);
 }
 
 void QMLOutput::setCloneOf(QMLOutput* other)
 {
     if (m_cloneOf == other) {
         return;
     }
 
     m_cloneOf = other;
     Q_EMIT cloneOfChanged();
 }
 
 QMLOutput* QMLOutput::cloneOf() const
 {
     return m_cloneOf;
 }
 
 int QMLOutput::currentOutputHeight() const
 {
     if (!m_output) {
         return 0;
     }
 
     KScreen::ModePtr mode = m_output->currentMode();
     if (!mode) {
         if (m_output->isConnected()) {
             mode = bestMode();
             if (!mode) {
                 return 1000;
             }
             m_output->setCurrentModeId(mode->id());
         } else {
             return 1000;
         }
     }
 
-    return mode->size().height();
+    return mode->size().height() / m_output->scale();
 }
 
 int QMLOutput::currentOutputWidth() const
 {
     if (!m_output) {
         return 0;
     }
 
     KScreen::ModePtr mode = m_output->currentMode();
     if (!mode) {
         if (m_output->isConnected()) {
             mode = bestMode();
             if (!mode) {
                 return 1000;
             }
             m_output->setCurrentModeId(mode->id());
         } else {
             return 1000;
         }
     }
 
-    return mode->size().width();
+    return mode->size().width() / m_output->scale();
 }
 
 void QMLOutput::currentModeIdChanged()
 {
     if (!m_output) {
         return;
     }
 
     if (m_rightDock) {
         QMLOutput *rightDock = m_rightDock;
         float newWidth = currentOutputWidth() * m_screen->outputScale();
         setX(rightDock->x() - newWidth);
         setRightDockedTo(rightDock);
     }
 
     if (m_bottomDock) {
         QMLOutput *bottomDock = m_bottomDock;
         float newHeight = currentOutputHeight() * m_screen->outputScale();
         setY(bottomDock->y() - newHeight);
         setBottomDockedTo(bottomDock);
     }
 
     Q_EMIT currentOutputSizeChanged();
 }
 
 
 int QMLOutput::outputX() const
 {
     return m_output->pos().x();
 }
 
 void QMLOutput::setOutputX(int x)
 {
     if (m_output->pos().rx() == x) {
         return;
     }
 
     QPoint pos = m_output->pos();
     pos.setX(x);
     m_output->setPos(pos);
     Q_EMIT outputXChanged();
 }
 
 int QMLOutput::outputY() const
 {
     return m_output->pos().y();
 }
 
 void QMLOutput::setOutputY(int y)
 {
     if (m_output->pos().ry() == y) {
         return;
     }
 
     QPoint pos = m_output->pos();
     pos.setY(y);
     m_output->setPos(pos);
     Q_EMIT outputYChanged();
 }
 
 bool QMLOutput::isCloneMode() const
 {
     return m_isCloneMode;
 }
 
 void QMLOutput::setIsCloneMode(bool isCloneMode)
 {
     if (m_isCloneMode == isCloneMode) {
         return;
     }
 
     m_isCloneMode = isCloneMode;
     Q_EMIT isCloneModeChanged();
 }
 
 void QMLOutput::dockToNeighbours()
 {
     Q_FOREACH (QMLOutput *otherQmlOutput, m_screen->outputs()) {
         if (otherQmlOutput == this) {
             continue;
         }
 
         if (!otherQmlOutput->output()->isConnected() || !otherQmlOutput->output()->isEnabled()) {
             continue;
         }
 
         const QRect geom = m_output->geometry();
         const QRect otherGeom = otherQmlOutput->output()->geometry();
 
         if (geom.left() - 1 == otherGeom.right()) {
             setLeftDockedTo(otherQmlOutput);
             continue;
         }
         if (geom.right() + 1 == otherGeom.left()) {
             setRightDockedTo(otherQmlOutput);
             continue;
         }
         if (geom.top() - 1 == otherGeom.bottom()) {
             setTopDockedTo(otherQmlOutput);
             continue;
         }
         if (geom.bottom() + 1 == otherGeom.top()) {
             setBottomDockedTo(otherQmlOutput);
             continue;
         }
     }
 }
 
 KScreen::ModePtr QMLOutput::bestMode() const
 {
     if (!m_output) {
         return KScreen::ModePtr();
     }
 
     KScreen::ModeList modes = m_output->modes();
     KScreen::ModePtr bestMode;
     Q_FOREACH (const KScreen::ModePtr &mode, modes) {
         if (!bestMode || (mode->size() > bestMode->size())) {
             bestMode = mode;
         }
     }
 
     return bestMode;
 }
 
 bool QMLOutput::collidesWithOutput(QObject *other)
 {
     QQuickItem* otherItem = qobject_cast<QQuickItem*>(other);
     return boundingRect().intersects(otherItem->boundingRect());
 }
 
 bool QMLOutput::maybeSnapTo(QMLOutput *other)
 {
     qreal centerX = x() + (width() / 2.0);
     qreal centerY = y() + (height() / 2.0);
 
     const qreal x2 = other->x();
     const qreal y2 = other->y();
     const qreal height2 = other->height();
     const qreal width2 = other->width();
     const qreal centerX2 = x2 + (width2 / 2.0);
     const qreal centerY2 = y2 + (height2 / 2.0);
 
     /* left of other */
     if ((x() + width() > x2 - sSnapArea) && (x() + width() < x2 + sSnapArea) &&
         (y() + height() > y2) && (y() < y2 + height2))
     {
         setX(x2 - width() + sMargin);
         centerX = x() + (width() / 2.0);
         setRightDockedTo(other);
         other->setLeftDockedTo(this);
         //output.cloneOf = null;
 
         /* output is snapped to other on left and their
          * upper sides are aligned */
         if ((y() < y2 + sSnapAlignArea) && (y() > y2 - sSnapAlignArea)) {
             setY(y2);
             return true;
         }
 
         /* output is snapped to other on left and they
          * are centered */
         if ((centerY < centerY2 + sSnapAlignArea) && (centerY > centerY2 - sSnapAlignArea)) {
             setY(centerY2 - (height() / 2.0));
             return true;
         }
 
         /* output is snapped to other on left and their
          * bottom sides are aligned */
         if ((y() + height() < y2 + height2 + sSnapAlignArea) && 
             (y() + height() > y2 + height2 - sSnapAlignArea))
         {
             setY(y2 + height2 - height());
             return true;
         }
 
         return true;
     }
 
     /* output is right of other */
     if ((x() > x2 + width2 - sSnapArea) && (x() < x2 + width2 + sSnapArea) &&
         (y() + height() > y2) && (y() < y2 + height2))
     {
         setX(x2 + width2 - sMargin);
         centerX = x() + (width() / 2.0);
         setLeftDockedTo(other);
         other->setRightDockedTo(this);
         //output.cloneOf = null;
 
         /* output is snapped to other on right and their
          * upper sides are aligned */
         if ((y() < y2 + sSnapAlignArea) && (y() > y2 - sSnapAlignArea)) {
             setY(y2);
             return true;
         }
 
         /* output is snapped to other on right and they
          * are centered */
         if ((centerY < centerY2 + sSnapAlignArea) && (centerY > centerY2 - sSnapAlignArea)) {
             setY(centerY2 - (height() / 2.0));
             return true;
         }
 
         /* output is snapped to other on right and their
          * bottom sides are aligned */
         if ((y() + height() < y2 + height2 + sSnapAlignArea) &&
             (y() + height() > y2 + height2 - sSnapAlignArea))
         {
             setY(y2 + height2 - height());
             return true;
         }
 
         return true;
     }
 
     /* output is above other */
     if ((y() + height() > y2 - sSnapArea) && (y() + height() < y2 + sSnapArea) &&
         (x() + width() > x2) && (x() < x2 + width2))
     {
         setY(y2 - height() + sMargin);
         centerY = y() + (height() / 2.0);
         setBottomDockedTo(other);
         other->setTopDockedTo(this);
         //output.cloneOf = null;
 
         /* output is snapped to other on top and their
          * left sides are aligned */
         if ((x() < x2 + sSnapAlignArea) && (x() > x2 - sSnapAlignArea)) {
             setX(x2);
             return true;
         }
 
         /* output is snapped to other on top and they
          * are centered */
         if ((centerX < centerX2 + sSnapAlignArea) && (centerX > centerX2 - sSnapAlignArea)) {
             setX(centerX2 - (width() / 2.0));
             return true;
         }
 
         /* output is snapped to other on top and their
          * right sides are aligned */
         if ((x() + width() < x2 + width2 + sSnapAlignArea) &&
             (x() + width() > x2 + width2 - sSnapAlignArea))
         {
             setX(x2 + width2 - width());
             return true;
         }
 
         return true;
     }
 
     /* output is below other */
     if ((y() > y2 + height2 - sSnapArea) && (y() < y2 + height2 + sSnapArea) &&
         (x() + width() > x2) && (x() < x2 + width2))
     {
         setY(y2 + height2 - sMargin);
         centerY = y() + (height() / 2.0);
         setTopDockedTo(other);
         other->setBottomDockedTo(this);
         //output.cloneOf = null;
 
         /* output is snapped to other on bottom and their
          * left sides are aligned */
         if ((x() < x2 + sSnapAlignArea) && (x() > x2 - sSnapAlignArea)) {
             setX(x2);
             return true;
         }
 
         /* output is snapped to other on bottom and they
          * are centered */
         if ((centerX < centerX2 + sSnapAlignArea) && (centerX > centerX2 - sSnapAlignArea)) {
             setX(centerX2 - (width() / 2.0));
             return true;
         }
 
         /* output is snapped to other on bottom and their
          * right sides are aligned */
         if ((x() + width() < x2 + width2 + sSnapAlignArea) &&
             (x() + width() > x2 + width2 - sSnapAlignArea))
         {
             setX(x2 + width2 - width());
             return true;
         }
 
         return true;
     }
 
     return false;
 }
 
 void QMLOutput::moved()
 {
     const QList<QQuickItem*> siblings = screen()->childItems();
 
     // First, if we have moved, then unset the "cloneOf" flag
     setCloneOf(0);
 
     disconnect(this, &QMLOutput::xChanged, this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
     disconnect(this, &QMLOutput::yChanged, this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
     Q_FOREACH (QQuickItem *sibling, siblings) {
         QMLOutput *otherOutput = qobject_cast<QMLOutput*>(sibling);
         if (!otherOutput || otherOutput == this) {
             continue;
         }
 
         if (!maybeSnapTo(otherOutput)) {
             if (m_leftDock == otherOutput) {
                 m_leftDock->undockRight();
                 undockLeft();
             }
             if (m_topDock == otherOutput) {
                 m_topDock->undockBottom();
                 undockTop();
             }
             if (m_rightDock == otherOutput) {
                 m_rightDock->undockLeft();
                 undockRight();
             }
             if (m_bottomDock == otherOutput) {
                 m_bottomDock->undockTop();
                 undockBottom();
             }
         }
     }
     connect(this, &QMLOutput::xChanged, this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
     connect(this, &QMLOutput::yChanged, this, static_cast<void(QMLOutput::*)()>(&QMLOutput::moved));
 
     Q_EMIT moved(m_output->name());
 }
 
 
 /* Transformation of an item (rotation of the MouseArea) is only visual.
  * The coordinates and dimensions are still the same (when you rotated
  * 100x500 rectangle by 90 deg, it will still be 100x500, although
  * visually it will be 500x100).
  *
  * This method calculates the real-visual coordinates and dimensions of
  * the MouseArea and updates root item to match them. This makes snapping
  * works correctly regardless on visual rotation of the output
  */
 void QMLOutput::updateRootProperties()
 {
     const float transformedWidth = (m_output->isHorizontal() ? currentOutputWidth() : currentOutputHeight()) * m_screen->outputScale();
     const float transformedHeight = (m_output->isHorizontal() ? currentOutputHeight() : currentOutputWidth()) * m_screen->outputScale();
 
     const float transformedX = x() + (width() / 2.0) - (transformedWidth / 2.0);
     const float transformedY = y() + (height() / 2.0) - (transformedHeight / 2.0);
 
     setPosition(QPointF(transformedX, transformedY));
     setSize(QSizeF(transformedWidth, transformedHeight));
 }