WIP: Introduce per-window scale factors

The qHighDpi functions now take an optional Window *
The scale factor can be set with QHighDpiScaling::
setWindowFactor(QWindow *, factor)

Change-Id: I34c80d2e031c257504d789ac5135de731d29929a

5 files changed, 102 insertions, 75 deletions

diff --git a/src/gui/kernel/qhighdpiscaling.cpp b/src/gui/kernel/qhighdpiscaling.cpp
index 6cdfd93860..9d563a9c74 100644
--- a/src/gui/kernel/qhighdpiscaling.cpp
+++ b/src/gui/kernel/qhighdpiscaling.cpp
@@ -74,6 +74,7 @@ static inline qreal initialScaleFactor()
 
 qreal QHighDpiScaling::m_factor = initialScaleFactor();
 bool QHighDpiScaling::m_active = !qFuzzyCompare(QHighDpiScaling::m_factor, qreal(1));
+bool QHighDpiScaling::m_perWindowActive = false;
 
 void QHighDpiScaling::setFactor(qreal factor)
 {
@@ -89,14 +90,31 @@ void QHighDpiScaling::setFactor(qreal factor)
          screen->d_func()->updateHighDpi();
 }
 
-Q_GUI_EXPORT QSize qHighDpiToDevicePixelsConstrained(const QSize &size)
+static const char *scaleFactorProperty = "_q_scaleFactor";
+
+void QHighDpiScaling::setWindowFactor(QWindow *window, qreal factor)
+{
+    m_perWindowActive = true;
+    window->setProperty(scaleFactorProperty, QVariant(factor));
+}
+
+qreal QHighDpiScaling::factor(const QWindow *window)
+{
+    if (m_perWindowActive || window == 0)
+        return m_factor;
+
+    QVariant windowFactor = window->property(scaleFactorProperty);
+    return m_factor * (windowFactor.isValid() ? windowFactor.toReal() : 1);
+}
+
+Q_GUI_EXPORT QSize qHighDpiToDevicePixelsConstrained(const QSize &size, const QWindow *window)
 {
     const int width = size.width();
     const int height = size.height();
     return QSize(width > 0 && width < QWINDOWSIZE_MAX ?
-                 qHighDpiToDevicePixels(width) : width,
+                 qHighDpiToDevicePixels(width, window) : width,
                  height > 0 && height < QWINDOWSIZE_MAX ?
-                 qHighDpiToDevicePixels(height) : height);
+                 qHighDpiToDevicePixels(height, window) : height);
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qhighdpiscaling_p.h b/src/gui/kernel/qhighdpiscaling_p.h
index 44382b7e88..372897fc1e 100644
--- a/src/gui/kernel/qhighdpiscaling_p.h
+++ b/src/gui/kernel/qhighdpiscaling_p.h
@@ -53,8 +53,14 @@
 //
 // The functions support creating a logical device-independent
 // coordinate system which is related to the device pixel coordinate
-// through a scaling factor. The scaling factor is set by the
-// QT_HIGHDPI_SCALE_FACTOR environment variable.
+// through a scaling factor.
+//
+// Several scaling factors can be set:
+//   - A process-global scale factor
+//       - the QT_HIGHDPI_SCALE_FACTOR environment variable.
+//       - QHighDpiScaling::setFactor(factor);
+//   - A per-window scale factor
+//       - QHighDpiScaling::setWindowFactor(window, factor);
 //
 // With these functions in use  most of the Qt API will then operate in
 // the device-independent coordinate system. For example, setting
@@ -70,180 +76,183 @@ QT_BEGIN_NAMESPACE
 class Q_GUI_EXPORT QHighDpiScaling {
 public:
     static bool isActive() { return m_active; }
-    static qreal factor()  { return m_factor; }
+    static qreal factor(const QWindow *window = 0);
     static void setFactor(qreal factor);
-
+    static void setWindowFactor(QWindow *window, qreal factor);
 private:
     static qreal m_factor;
     static bool m_active;
+    static bool m_perWindowActive;
 };
 
 // Coordinate system conversion functions:
 // qHighDpiToDeviceIndependentPixels   : from physical(screen/backing) to logical pixels
 // qHighDpiToDevicePixels              : from logical to physical pixels
-inline QRect qHighDpiToDeviceIndependentPixels(const QRect &pixelRect)
+inline QRect qHighDpiToDeviceIndependentPixels(const QRect &pixelRect, const QWindow *window = 0)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor();
+    const qreal scaleFactor = QHighDpiScaling::factor(window);
     return QRect(pixelRect.topLeft() / scaleFactor, pixelRect.size() / scaleFactor);
 }
 
-inline QRect qHighDpiToDevicePixels(const QRect &pointRect)
+inline QRect qHighDpiToDevicePixels(const QRect &pointRect, const QWindow *window = 0)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor();
+    const qreal scaleFactor = QHighDpiScaling::factor(window);
     return QRect(pointRect.topLeft() * scaleFactor, pointRect.size() * scaleFactor);
 }
 
-inline QRectF qHighDpiToDeviceIndependentPixels(const QRectF &pixelRect)
+inline QRectF qHighDpiToDeviceIndependentPixels(const QRectF &pixelRect, const QWindow *window = 0)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor();
+    const qreal scaleFactor = QHighDpiScaling::factor(window);
     return QRectF(pixelRect.topLeft() / scaleFactor, pixelRect.size() / scaleFactor);
 }
 
-inline QRectF qHighDpiToDevicePixels(const QRectF &pointRect)
+inline QRectF qHighDpiToDevicePixels(const QRectF &pointRect, const QWindow *window = 0)
 {
-   const qreal scaleFactor = QHighDpiScaling::factor();
+   const qreal scaleFactor = QHighDpiScaling::factor(window);
    return QRectF(pointRect.topLeft() * scaleFactor, pointRect.size() * scaleFactor);
 }
 
-inline QSize qHighDpiToDeviceIndependentPixels(const QSize &pixelSize)
+inline QSize qHighDpiToDeviceIndependentPixels(const QSize &pixelSize, const QWindow *window = 0)
 {
-    return pixelSize / QHighDpiScaling::factor();
+    return pixelSize / QHighDpiScaling::factor(window);
 }
 
 // For converting minimum/maximum sizes of QWindow, limits to 0..QWINDOWSIZE_MAX
-Q_GUI_EXPORT QSize qHighDpiToDevicePixelsConstrained(const QSize &size);
+Q_GUI_EXPORT QSize qHighDpiToDevicePixelsConstrained(const QSize &size, const QWindow *window = 0);
 
-inline QSize qHighDpiToDevicePixels(const QSize &pointSize)
+inline QSize qHighDpiToDevicePixels(const QSize &pointSize, const QWindow *window = 0)
 {
-    return pointSize * QHighDpiScaling::factor();
+    return pointSize * QHighDpiScaling::factor(window);
 }
 
-inline QSizeF qHighDpiToDeviceIndependentPixels(const QSizeF &pixelSize)
+inline QSizeF qHighDpiToDeviceIndependentPixels(const QSizeF &pixelSize, const QWindow *window = 0)
 {
-    return pixelSize / QHighDpiScaling::factor();
+    return pixelSize / QHighDpiScaling::factor(window);
 }
 
-inline QSizeF qHighDpiToDevicePixels(const QSizeF &pointSize)
+inline QSizeF qHighDpiToDevicePixels(const QSizeF &pointSize, const QWindow *window = 0)
 {
-    return pointSize * QHighDpiScaling::factor();
+    return pointSize * QHighDpiScaling::factor(window);
 }
 
-inline QPoint qHighDpiToDeviceIndependentPixels(const QPoint &pixelPoint)
+inline QPoint qHighDpiToDeviceIndependentPixels(const QPoint &pixelPoint, const QWindow *window = 0)
 {
-    return pixelPoint / QHighDpiScaling::factor();
+    return pixelPoint / QHighDpiScaling::factor(window);
 }
 
-inline QPoint qHighDpiToDevicePixels(const QPoint &pointPoint)
+inline QPoint qHighDpiToDevicePixels(const QPoint &pointPoint, const QWindow *window = 0)
 {
-    return pointPoint * QHighDpiScaling::factor();
+    return pointPoint * QHighDpiScaling::factor(window);
 }
 
-inline QPointF qHighDpiToDeviceIndependentPixels(const QPointF &pixelPoint)
+inline QPointF qHighDpiToDeviceIndependentPixels(const QPointF &pixelPoint, const QWindow *window = 0)
 {
-    return pixelPoint / QHighDpiScaling::factor();
+    return pixelPoint / QHighDpiScaling::factor(window);
 }
 
-inline QPointF qHighDpiToDevicePixels(const QPointF &pointPoint)
+inline QPointF qHighDpiToDevicePixels(const QPointF &pointPoint, const QWindow *window = 0)
 {
-    return pointPoint * QHighDpiScaling::factor();
+    return pointPoint * QHighDpiScaling::factor(window);
 }
 
-inline QMargins qHighDpiToDeviceIndependentPixels(const QMargins &pixelMargins)
+inline QMargins qHighDpiToDeviceIndependentPixels(const QMargins &pixelMargins, const QWindow *window = 0)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor();
+    const qreal scaleFactor = QHighDpiScaling::factor(window);
     return QMargins(pixelMargins.left() / scaleFactor, pixelMargins.top() / scaleFactor,
                     pixelMargins.right() / scaleFactor, pixelMargins.bottom() / scaleFactor);
 }
 
-inline QMargins qHighDpiToDevicePixels(const QMargins &pointMargins)
+inline QMargins qHighDpiToDevicePixels(const QMargins &pointMargins, const QWindow *window = 0)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor();
+    const qreal scaleFactor = QHighDpiScaling::factor(window);
     return QMargins(pointMargins.left() * scaleFactor, pointMargins.top() * scaleFactor,
                     pointMargins.right() * scaleFactor, pointMargins.bottom() * scaleFactor);
 }
 
-inline QRegion qHighDpiToDeviceIndependentPixels(const QRegion &pixelRegion)
+inline QRegion qHighDpiToDeviceIndependentPixels(const QRegion &pixelRegion, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pixelRegion;
 
     QRegion pointRegion;
     foreach (const QRect &rect, pixelRegion.rects())
-        pointRegion += qHighDpiToDeviceIndependentPixels(rect);
+        pointRegion += qHighDpiToDeviceIndependentPixels(rect, window);
     return pointRegion;
 }
 
-inline QRegion qHighDpiToDevicePixels(const QRegion &pointRegion)
+inline QRegion qHighDpiToDevicePixels(const QRegion &pointRegion, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pointRegion;
 
     QRegion pixelRegon;
     foreach (const QRect &rect, pointRegion.rects())
-        pixelRegon += qHighDpiToDevicePixels(rect);
+        pixelRegon += qHighDpiToDevicePixels(rect, window);
     return pixelRegon;
 }
 
 // Any T that has operator/()
 template <typename T>
-T qHighDpiToDeviceIndependentPixels(const T &pixelValue)
+T qHighDpiToDeviceIndependentPixels(const T &pixelValue, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pixelValue;
 
-    return pixelValue / QHighDpiScaling::factor();
+    return pixelValue / QHighDpiScaling::factor(window);
 
 }
 
 // Any T that has operator*()
 template <typename T>
-T qHighDpiToDevicePixels(const T &pointValue)
+T qHighDpiToDevicePixels(const T &pointValue, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pointValue;
 
-    return pointValue * QHighDpiScaling::factor();
+    return pointValue * QHighDpiScaling::factor(window);
 }
 
 // Any QVector<T> where T has operator/()
 template <typename T>
-QVector<T> qHighDpiToDeviceIndependentPixels(const QVector<T> &pixelValues)
+QVector<T> qHighDpiToDeviceIndependentPixels(const QVector<T> &pixelValues, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pixelValues;
 
     QVector<T> pointValues;
     foreach (const T& pixelValue, pixelValues)
-        pointValues.append(pixelValue / QHighDpiScaling::factor());
+        pointValues.append(pixelValue / QHighDpiScaling::factor(window));
     return pointValues;
 }
 
 // Any QVector<T> where T has operator*()
 template <typename T>
-QVector<T> qHighDpiToDevicePixels(const QVector<T> &pointValues)
+QVector<T> qHighDpiToDevicePixels(const QVector<T> &pointValues, const QWindow *window = 0)
 {
     if (!QHighDpiScaling::isActive())
         return pointValues;
 
     QVector<T> pixelValues;
     foreach (const T& pointValue, pointValues)
-        pixelValues.append(pointValue * QHighDpiScaling::factor());
+        pixelValues.append(pointValue * QHighDpiScaling::factor(window));
     return pixelValues;
 }
 
 
 // Any QPair<T, U> where T and U has operator/()
 template <typename T, typename U>
-QPair<T, U> qHighDpiToDeviceIndependentPixels(const QPair<T, U> &pixelPair)
+QPair<T, U> qHighDpiToDeviceIndependentPixels(const QPair<T, U> &pixelPair, const QWindow *window = 0)
 {
-    return qMakePair(qHighDpiToDeviceIndependentPixels(pixelPair.first), qHighDpiToDeviceIndependentPixels(pixelPair.second));
+    return qMakePair(qHighDpiToDeviceIndependentPixels(pixelPair.first, window),
+                     qHighDpiToDeviceIndependentPixels(pixelPair.second, window));
 }
 
 // Any QPair<T, U> where T and U has operator*()
 template <typename T, typename U>
-QPair<T, U> qHighDpiToDevicePixels(const QPair<T, U> &pointPair)
+QPair<T, U> qHighDpiToDevicePixels(const QPair<T, U> &pointPair, const QWindow *window = 0)
 {
-    return qMakePair(qHighDpiToDevicePixels(pointPair.first), qHighDpiToDevicePixels(pointPair.second));
+    return qMakePair(qHighDpiToDevicePixels(pointPair.first, window),
+                     qHighDpiToDevicePixels(pointPair.second, window));
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qwindow.cpp b/src/gui/kernel/qwindow.cpp
index c75907a578..0a732c2a52 100644
--- a/src/gui/kernel/qwindow.cpp
+++ b/src/gui/kernel/qwindow.cpp
@@ -1421,7 +1421,7 @@ void QWindow::setGeometry(const QRect &rect)
 
     d->positionPolicy = QWindowPrivate::WindowFrameExclusive;
     if (d->platformWindow) {
-        d->platformWindow->setGeometry(qHighDpiToDevicePixels(rect));
+        d->platformWindow->setGeometry(qHighDpiToDevicePixels(rect, this));
     } else {
         d->geometry = rect;
 
@@ -1445,7 +1445,7 @@ QRect QWindow::geometry() const
 {
     Q_D(const QWindow);
     if (d->platformWindow)
-        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry());
+        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry(), this);
     return d->geometry;
 }
 
@@ -1458,7 +1458,7 @@ QMargins QWindow::frameMargins() const
 {
     Q_D(const QWindow);
     if (d->platformWindow)
-        return qHighDpiToDeviceIndependentPixels(d->platformWindow->frameMargins());
+        return qHighDpiToDeviceIndependentPixels(d->platformWindow->frameMargins(), this);
     return QMargins();
 }
 
@@ -1472,7 +1472,7 @@ QRect QWindow::frameGeometry() const
     Q_D(const QWindow);
     if (d->platformWindow) {
         QMargins m = frameMargins();
-        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry()).adjusted(-m.left(), -m.top(), m.right(), m.bottom());
+        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry(), this).adjusted(-m.left(), -m.top(), m.right(), m.bottom());
     }
     return d->geometry;
 }
@@ -1489,7 +1489,7 @@ QPoint QWindow::framePosition() const
     Q_D(const QWindow);
     if (d->platformWindow) {
         QMargins margins = frameMargins();
-        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry().topLeft()) - QPoint(margins.left(), margins.top());
+        return qHighDpiToDeviceIndependentPixels(d->platformWindow->geometry().topLeft(), this) - QPoint(margins.left(), margins.top());
     }
     return d->geometry.topLeft();
 }
@@ -1504,7 +1504,7 @@ void QWindow::setFramePosition(const QPoint &point)
     Q_D(QWindow);
     d->positionPolicy = QWindowPrivate::WindowFrameInclusive;
     if (d->platformWindow) {
-        d->platformWindow->setGeometry(qHighDpiToDevicePixels(QRect(point, size())));
+        d->platformWindow->setGeometry(qHighDpiToDevicePixels(QRect(point, size()), this));
     } else {
         d->positionAutomatic = false;
         d->geometry.moveTopLeft(point);
@@ -1565,7 +1565,7 @@ void QWindow::resize(const QSize &newSize)
 {
     Q_D(QWindow);
     if (d->platformWindow) {
-        d->platformWindow->setGeometry(qHighDpiToDevicePixels(QRect(position(), newSize)));
+        d->platformWindow->setGeometry(qHighDpiToDevicePixels(QRect(position(), newSize), this));
     } else {
         const QSize oldSize = d->geometry.size();
         d->geometry.setSize(newSize);
diff --git a/src/gui/kernel/qwindowsysteminterface.cpp b/src/gui/kernel/qwindowsysteminterface.cpp
index da3b3e85e5..808ef9fd66 100644
--- a/src/gui/kernel/qwindowsysteminterface.cpp
+++ b/src/gui/kernel/qwindowsysteminterface.cpp
@@ -139,7 +139,7 @@ void QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationState
  */
 void QWindowSystemInterface::handleGeometryChange(QWindow *tlw, const QRect &newRect, const QRect &oldRect)
 {
-    QWindowSystemInterfacePrivate::GeometryChangeEvent *e = new QWindowSystemInterfacePrivate::GeometryChangeEvent(tlw, qHighDpiToDeviceIndependentPixels(newRect), qHighDpiToDeviceIndependentPixels(oldRect));
+    QWindowSystemInterfacePrivate::GeometryChangeEvent *e = new QWindowSystemInterfacePrivate::GeometryChangeEvent(tlw, qHighDpiToDeviceIndependentPixels(newRect, tlw), qHighDpiToDeviceIndependentPixels(oldRect, tlw));
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -168,7 +168,7 @@ void QWindowSystemInterface::handleMouseEvent(QWindow *w, ulong timestamp, const
                                               Qt::KeyboardModifiers mods, Qt::MouseEventSource source)
 {
     QWindowSystemInterfacePrivate::MouseEvent * e =
-        new QWindowSystemInterfacePrivate::MouseEvent(w, timestamp, qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), b, mods, source);
+        new QWindowSystemInterfacePrivate::MouseEvent(w, timestamp, qHighDpiToDeviceIndependentPixels(local, w), qHighDpiToDeviceIndependentPixels(global, w), b, mods, source);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -185,7 +185,7 @@ void QWindowSystemInterface::handleFrameStrutMouseEvent(QWindow *w, ulong timest
     QWindowSystemInterfacePrivate::MouseEvent * e =
             new QWindowSystemInterfacePrivate::MouseEvent(w, timestamp,
                                                           QWindowSystemInterfacePrivate::FrameStrutMouse,
-                                                          qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), b, mods, source);
+                                                          qHighDpiToDeviceIndependentPixels(local, w), qHighDpiToDeviceIndependentPixels(global, w), b, mods, source);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -366,14 +366,14 @@ void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, con
 
     // Simple case: vertical deltas only:
     if (angleDelta.y() != 0 && angleDelta.x() == 0) {
-        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
+        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local, tlw), qHighDpiToDeviceIndependentPixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
         QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
         return;
     }
 
     // Simple case: horizontal deltas only:
     if (angleDelta.y() == 0 && angleDelta.x() != 0) {
-        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), pixelDelta, angleDelta, angleDelta.x(), Qt::Horizontal, mods, phase, source);
+        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local, tlw), qHighDpiToDeviceIndependentPixels(global, tlw), pixelDelta, angleDelta, angleDelta.x(), Qt::Horizontal, mods, phase, source);
         QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
         return;
     }
@@ -381,12 +381,12 @@ void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, con
     // Both horizontal and vertical deltas: Send two wheel events.
     // The first event contains the Qt 5 pixel and angle delta as points,
     // and in addition the Qt 4 compatibility vertical angle delta.
-    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
+    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local, tlw), qHighDpiToDeviceIndependentPixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 
     // The second event contains null pixel and angle points and the
     // Qt 4 compatibility horizontal angle delta.
-    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local), qHighDpiToDeviceIndependentPixels(global), QPoint(), QPoint(), angleDelta.x(), Qt::Horizontal, mods, phase, source);
+    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, qHighDpiToDeviceIndependentPixels(local, tlw), qHighDpiToDeviceIndependentPixels(global, tlw), QPoint(), QPoint(), angleDelta.x(), Qt::Horizontal, mods, phase, source);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -560,7 +560,7 @@ void QWindowSystemInterface::handleThemeChange(QWindow *tlw)
 
 void QWindowSystemInterface::handleExposeEvent(QWindow *tlw, const QRegion &region)
 {
-    QWindowSystemInterfacePrivate::ExposeEvent *e = new QWindowSystemInterfacePrivate::ExposeEvent(tlw, qHighDpiToDeviceIndependentPixels(region));
+    QWindowSystemInterfacePrivate::ExposeEvent *e = new QWindowSystemInterfacePrivate::ExposeEvent(tlw, qHighDpiToDeviceIndependentPixels(region, tlw));
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -627,12 +627,12 @@ int QWindowSystemInterface::windowSystemEventsQueued()
 #ifndef QT_NO_DRAGANDDROP
 QPlatformDragQtResponse QWindowSystemInterface::handleDrag(QWindow *w, const QMimeData *dropData, const QPoint &p, Qt::DropActions supportedActions)
 {
-    return QGuiApplicationPrivate::processDrag(w, dropData, qHighDpiToDeviceIndependentPixels(p),supportedActions);
+    return QGuiApplicationPrivate::processDrag(w, dropData, qHighDpiToDeviceIndependentPixels(p, w),supportedActions);
 }
 
 QPlatformDropQtResponse QWindowSystemInterface::handleDrop(QWindow *w, const QMimeData *dropData, const QPoint &p, Qt::DropActions supportedActions)
 {
-    return QGuiApplicationPrivate::processDrop(w, dropData, qHighDpiToDeviceIndependentPixels(p),supportedActions);
+    return QGuiApplicationPrivate::processDrop(w, dropData, qHighDpiToDeviceIndependentPixels(p, w),supportedActions);
 }
 #endif // QT_NO_DRAGANDDROP
 
@@ -667,8 +667,8 @@ void QWindowSystemInterface::handleTabletEvent(QWindow *w, ulong timestamp, cons
 {
     QWindowSystemInterfacePrivate::TabletEvent *e =
         new QWindowSystemInterfacePrivate::TabletEvent(w,timestamp,
-                                                       qHighDpiToDeviceIndependentPixels(local),
-                                                       qHighDpiToDeviceIndependentPixels(global),
+                                                       qHighDpiToDeviceIndependentPixels(local, w),
+                                                       qHighDpiToDeviceIndependentPixels(global, w),
                                                        device, pointerType, buttons, pressure,
                                                        xTilt, yTilt, tangentialPressure, rotation, z, uid, modifiers);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
@@ -795,7 +795,7 @@ Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QWindowSystemInterface::TouchPo
 
 Q_GUI_EXPORT void qt_handleMouseEvent(QWindow *w, const QPointF & local, const QPointF & global, Qt::MouseButtons b, Qt::KeyboardModifiers mods = Qt::NoModifier) {
 
-    QWindowSystemInterface::handleMouseEvent(w, qHighDpiToDevicePixels(local), qHighDpiToDevicePixels(global),  b,  mods);
+    QWindowSystemInterface::handleMouseEvent(w, qHighDpiToDevicePixels(local, w), qHighDpiToDevicePixels(global, w),  b,  mods);
 }
 
 Q_GUI_EXPORT void qt_handleKeyEvent(QWindow *w, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1)
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index 88e9aaac2c..20f5c5e22c 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -104,7 +104,7 @@ void QBackingStore::flush(const QRegion &region, QWindow *win, const QPoint &off
     }
 #endif
 
-    d_ptr->platformBackingStore->flush(win, qHighDpiToDevicePixels(region), offset);
+    d_ptr->platformBackingStore->flush(win, qHighDpiToDevicePixels(region, d_ptr->window), offset);
 }
 
 /*!
@@ -162,7 +162,7 @@ QWindow* QBackingStore::window() const
 
 void QBackingStore::beginPaint(const QRegion &region)
 {
-    d_ptr->platformBackingStore->beginPaint(qHighDpiToDevicePixels(region));
+    d_ptr->platformBackingStore->beginPaint(qHighDpiToDevicePixels(region, d_ptr->window));
 }
 
 /*!
@@ -206,7 +206,7 @@ bool QBackingStore::scroll(const QRegion &area, int dx, int dy)
     Q_UNUSED(dx);
     Q_UNUSED(dy);
 
-    return d_ptr->platformBackingStore->scroll(qHighDpiToDevicePixels(area), qHighDpiToDevicePixels(dx), qHighDpiToDevicePixels(dy));
+    return d_ptr->platformBackingStore->scroll(qHighDpiToDevicePixels(area, d_ptr->window), qHighDpiToDevicePixels(dx, d_ptr->window), qHighDpiToDevicePixels(dy, d_ptr->window));
 }
 
 void QBackingStore::setStaticContents(const QRegion &region)