Merge 5.4 into 5.4.1

Change-Id: I78d848c0bb396584a205a8066d253f2bcac8da56

21 files changed, 272 insertions, 56 deletions

diff --git a/src/plugins/platforms/android/androidjnimain.cpp b/src/plugins/platforms/android/androidjnimain.cpp
index d1e78dfe5d..1c157c79c3 100644
--- a/src/plugins/platforms/android/androidjnimain.cpp
+++ b/src/plugins/platforms/android/androidjnimain.cpp
@@ -376,8 +376,6 @@ namespace QtAndroid
         const auto &it = m_surfaces.find(surfaceId);
         if (it != m_surfaces.end())
             m_surfaces.remove(surfaceId);
-        if (m_surfaces.isEmpty())
-            m_surfaceId = 1;
 
         QJNIEnvironmentPrivate env;
         if (!env)
diff --git a/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp b/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp
index 5781f0d7c6..4c38178343 100644
--- a/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp
+++ b/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp
@@ -50,8 +50,10 @@ QAndroidPlatformOpenGLContext::QAndroidPlatformOpenGLContext(const QSurfaceForma
 
 void QAndroidPlatformOpenGLContext::swapBuffers(QPlatformSurface *surface)
 {
-    if (surface->surface()->surfaceClass() == QSurface::Window)
-        static_cast<QAndroidPlatformOpenGLWindow *>(surface)->checkNativeSurface(eglConfig());
+    if (surface->surface()->surfaceClass() == QSurface::Window &&
+            static_cast<QAndroidPlatformOpenGLWindow *>(surface)->checkNativeSurface(eglConfig())) {
+        QEGLPlatformContext::makeCurrent(surface);
+    }
 
     QEGLPlatformContext::swapBuffers(surface);
 }
diff --git a/src/plugins/platforms/android/qandroidplatformopenglwindow.cpp b/src/plugins/platforms/android/qandroidplatformopenglwindow.cpp
index 8dc8e84f0a..de7f1f6990 100644
--- a/src/plugins/platforms/android/qandroidplatformopenglwindow.cpp
+++ b/src/plugins/platforms/android/qandroidplatformopenglwindow.cpp
@@ -138,19 +138,19 @@ EGLSurface QAndroidPlatformOpenGLWindow::eglSurface(EGLConfig config)
     return m_eglSurface;
 }
 
-void QAndroidPlatformOpenGLWindow::checkNativeSurface(EGLConfig config)
+bool QAndroidPlatformOpenGLWindow::checkNativeSurface(EGLConfig config)
 {
     QMutexLocker lock(&m_surfaceMutex);
     if (m_nativeSurfaceId == -1 || !m_androidSurfaceObject.isValid())
-        return;
+        return false; // makeCurrent is NOT needed.
 
     createEgl(config);
 
-
     // we've create another surface, the window should be repainted
     QRect availableGeometry = screen()->availableGeometry();
     if (geometry().width() > 0 && geometry().height() > 0 && availableGeometry.width() > 0 && availableGeometry.height() > 0)
         QWindowSystemInterface::handleExposeEvent(window(), QRegion(QRect(QPoint(), geometry().size())));
+    return true; // makeCurrent is needed!
 }
 
 void QAndroidPlatformOpenGLWindow::applicationStateChanged(Qt::ApplicationState state)
@@ -209,15 +209,19 @@ void QAndroidPlatformOpenGLWindow::surfaceChanged(JNIEnv *jniEnv, jobject surfac
     Q_UNUSED(jniEnv);
     Q_UNUSED(w);
     Q_UNUSED(h);
+
     lockSurface();
     m_androidSurfaceObject = surface;
-    m_surfaceWaitCondition.wakeOne();
+    if (surface) // wait until we have a valid surface to draw into
+        m_surfaceWaitCondition.wakeOne();
     unlockSurface();
 
-    // repaint the window
-    QRect availableGeometry = screen()->availableGeometry();
-    if (geometry().width() > 0 && geometry().height() > 0 && availableGeometry.width() > 0 && availableGeometry.height() > 0)
-        QWindowSystemInterface::handleExposeEvent(window(), QRegion(QRect(QPoint(), geometry().size())));
+    if (surface) {
+        // repaint the window, when we have a valid surface
+        QRect availableGeometry = screen()->availableGeometry();
+        if (geometry().width() > 0 && geometry().height() > 0 && availableGeometry.width() > 0 && availableGeometry.height() > 0)
+            QWindowSystemInterface::handleExposeEvent(window(), QRegion(QRect(QPoint(), geometry().size())));
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/android/qandroidplatformopenglwindow.h b/src/plugins/platforms/android/qandroidplatformopenglwindow.h
index 71787edee1..6d6548fc6a 100644
--- a/src/plugins/platforms/android/qandroidplatformopenglwindow.h
+++ b/src/plugins/platforms/android/qandroidplatformopenglwindow.h
@@ -54,7 +54,7 @@ public:
     EGLSurface eglSurface(EGLConfig config);
     QSurfaceFormat format() const;
 
-    void checkNativeSurface(EGLConfig config);
+    bool checkNativeSurface(EGLConfig config);
 
     void applicationStateChanged(Qt::ApplicationState);
 
@@ -66,7 +66,7 @@ protected:
     void clearEgl();
 
 private:
-    EGLDisplay m_eglDisplay;
+    EGLDisplay m_eglDisplay = EGL_NO_DISPLAY;
     EGLSurface m_eglSurface = EGL_NO_SURFACE;
     EGLNativeWindowType m_nativeWindow = nullptr;
 
diff --git a/src/plugins/platforms/android/qandroidplatformscreen.cpp b/src/plugins/platforms/android/qandroidplatformscreen.cpp
index b70f936be1..092ade2e4a 100644
--- a/src/plugins/platforms/android/qandroidplatformscreen.cpp
+++ b/src/plugins/platforms/android/qandroidplatformscreen.cpp
@@ -391,7 +391,7 @@ Qt::ScreenOrientation QAndroidPlatformScreen::nativeOrientation() const
 void QAndroidPlatformScreen::surfaceChanged(JNIEnv *env, jobject surface, int w, int h)
 {
     lockSurface();
-    if (surface && w && h) {
+    if (surface && w > 0  && h > 0) {
         releaseSurface();
         m_nativeSurface = ANativeWindow_fromSurface(env, surface);
         QMetaObject::invokeMethod(this, "setDirty", Qt::QueuedConnection, Q_ARG(QRect, QRect(0, 0, w, h)));
diff --git a/src/plugins/platforms/cocoa/qnsview.h b/src/plugins/platforms/cocoa/qnsview.h
index 8d8df13dc3..fa71ab4086 100644
--- a/src/plugins/platforms/cocoa/qnsview.h
+++ b/src/plugins/platforms/cocoa/qnsview.h
@@ -48,7 +48,7 @@ class QCocoaBackingStore;
 class QCocoaGLContext;
 QT_END_NAMESPACE
 
-Q_FORWARD_DECLARE_OBJC_CLASS(QNSViewMouseMoveHelper);
+Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
 
 @interface QT_MANGLE_NAMESPACE(QNSView) : NSView <NSTextInputClient> {
     QImage m_backingStore;
@@ -72,7 +72,7 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QNSViewMouseMoveHelper);
     bool m_shouldSetGLContextinDrawRect;
 #endif
     NSString *m_inputSource;
-    QNSViewMouseMoveHelper *m_mouseMoveHelper;
+    QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper) *m_mouseMoveHelper;
     bool m_resendKeyEvent;
 }
 
diff --git a/src/plugins/platforms/cocoa/qnsview.mm b/src/plugins/platforms/cocoa/qnsview.mm
index 699340795d..771b464805 100644
--- a/src/plugins/platforms/cocoa/qnsview.mm
+++ b/src/plugins/platforms/cocoa/qnsview.mm
@@ -83,7 +83,7 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
   - (CGFloat)deviceDeltaZ;
 @end
 
-@interface QNSViewMouseMoveHelper : NSObject
+@interface QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper) : NSObject
 {
     QNSView *view;
 }
@@ -97,7 +97,7 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
 
 @end
 
-@implementation QNSViewMouseMoveHelper
+@implementation QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper)
 
 - (id)initWithView:(QNSView *)theView
 {
@@ -158,7 +158,7 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
         currentCustomDragTypes = 0;
         m_sendUpAsRightButton = false;
         m_inputSource = 0;
-        m_mouseMoveHelper = [[QNSViewMouseMoveHelper alloc] initWithView:self];
+        m_mouseMoveHelper = [[QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper) alloc] initWithView:self];
         m_resendKeyEvent = false;
 
         if (!touchDevice) {
diff --git a/src/plugins/platforms/ios/qiosscreen.mm b/src/plugins/platforms/ios/qiosscreen.mm
index 4af2a4965f..712bf0098b 100644
--- a/src/plugins/platforms/ios/qiosscreen.mm
+++ b/src/plugins/platforms/ios/qiosscreen.mm
@@ -46,6 +46,7 @@
 #include <qpa/qwindowsysteminterface.h>
 #include "qiosapplicationdelegate.h"
 #include "qiosviewcontroller.h"
+#include "quiview.h"
 
 #include <sys/sysctl.h>
 
@@ -244,6 +245,22 @@ void QIOSScreen::updateProperties()
     m_geometry = fromCGRect([rootView convertRect:m_uiScreen.bounds fromView:m_uiWindow]).toRect();
     m_availableGeometry = fromCGRect([rootView convertRect:m_uiScreen.applicationFrame fromView:m_uiWindow]).toRect();
 
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_IOS_8_0 && ![m_uiWindow.rootViewController shouldAutorotate]) {
+        // Setting the statusbar orientation (content orientation) on iOS8+ will result in the UIScreen
+        // updating its geometry and available geometry, which in the case of content orientation is not
+        // what we want. We want to reflect the screen geometry based on the locked orientation, and
+        // adjust the available geometry based on the repositioned status bar for the current status
+        // bar orientation.
+
+        Qt::ScreenOrientation lockedOrientation = toQtScreenOrientation(UIDeviceOrientation(rootView.qtViewController.lockedOrientation));
+        Qt::ScreenOrientation contenOrientation = toQtScreenOrientation(UIDeviceOrientation([UIApplication sharedApplication].statusBarOrientation));
+
+        QTransform transform = screen()->transformBetween(lockedOrientation, contenOrientation, m_geometry).inverted();
+
+        m_geometry = transform.mapRect(m_geometry);
+        m_availableGeometry = transform.mapRect(m_availableGeometry);
+    }
+
     if (m_geometry != previousGeometry || m_availableGeometry != previousAvailableGeometry) {
         const qreal millimetersPerInch = 25.4;
         m_physicalSize = QSizeF(m_geometry.size()) / m_unscaledDpi * millimetersPerInch;
diff --git a/src/plugins/platforms/ios/qiostextresponder.h b/src/plugins/platforms/ios/qiostextresponder.h
index 118ab8958a..21b61bf8da 100644
--- a/src/plugins/platforms/ios/qiostextresponder.h
+++ b/src/plugins/platforms/ios/qiostextresponder.h
@@ -51,6 +51,7 @@ class QIOSInputContext;
     QIOSInputContext *m_inputContext;
     QString m_markedText;
     BOOL m_inSendEventToFocusObject;
+    BOOL m_inSelectionChange;
 }
 
 - (id)initWithInputContext:(QIOSInputContext *)context;
diff --git a/src/plugins/platforms/ios/qiostextresponder.mm b/src/plugins/platforms/ios/qiostextresponder.mm
index bebc7577f8..15fade0838 100644
--- a/src/plugins/platforms/ios/qiostextresponder.mm
+++ b/src/plugins/platforms/ios/qiostextresponder.mm
@@ -171,6 +171,7 @@
         return self;
 
     m_inSendEventToFocusObject = NO;
+    m_inSelectionChange = NO;
     m_inputContext = inputContext;
 
     QVariantMap platformData = [self imValue:Qt::ImPlatformData].toMap();
@@ -302,6 +303,7 @@
         return;
 
     if (updatedProperties & (Qt::ImCursorPosition | Qt::ImAnchorPosition)) {
+        QScopedValueRollback<BOOL> rollback(m_inSelectionChange, true);
         [self.inputDelegate selectionWillChange:self];
         [self.inputDelegate selectionDidChange:self];
     }
@@ -349,6 +351,15 @@
 
 - (void)setSelectedTextRange:(UITextRange *)range
 {
+    if (m_inSelectionChange) {
+        // After [UITextInputDelegate selectionWillChange], UIKit will cancel
+        // any ongoing auto correction (if enabled) and ask us to set an empty selection.
+        // This is contradictory to our current attempt to set a selection, so we ignore
+        // the callback. UIKit will be re-notified of the new selection after
+        // [UITextInputDelegate selectionDidChange].
+        return;
+    }
+
     QUITextRange *r = static_cast<QUITextRange *>(range);
     QList<QInputMethodEvent::Attribute> attrs;
     attrs << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, r.range.location, r.range.length, 0);
diff --git a/src/plugins/platforms/ios/qiosviewcontroller.h b/src/plugins/platforms/ios/qiosviewcontroller.h
index 586edd589d..df7ce0ff4a 100644
--- a/src/plugins/platforms/ios/qiosviewcontroller.h
+++ b/src/plugins/platforms/ios/qiosviewcontroller.h
@@ -35,15 +35,17 @@
 
 class QIOSScreen;
 
-@interface QIOSViewController : UIViewController {
-    QIOSScreen *m_screen;
-}
+@interface QIOSViewController : UIViewController
 
-@property (nonatomic, assign) BOOL changingOrientation;
+- (id)initWithQIOSScreen:(QIOSScreen *)screen;
+- (void)updateProperties;
+
+@property (nonatomic, assign) UIInterfaceOrientation lockedOrientation;
+
+// UIViewController
+@property (nonatomic, assign) BOOL shouldAutorotate;
 @property (nonatomic, assign) BOOL prefersStatusBarHidden;
 @property (nonatomic, assign) UIStatusBarAnimation preferredStatusBarUpdateAnimation;
 
-- (id)initWithQIOSScreen:(QIOSScreen *)screen;
-- (void)updateProperties;
 @end
 
diff --git a/src/plugins/platforms/ios/qiosviewcontroller.mm b/src/plugins/platforms/ios/qiosviewcontroller.mm
index f678f7e807..01bc84ae68 100644
--- a/src/plugins/platforms/ios/qiosviewcontroller.mm
+++ b/src/plugins/platforms/ios/qiosviewcontroller.mm
@@ -41,6 +41,8 @@
 
 #import "qiosviewcontroller.h"
 
+#include <QtCore/qscopedvaluerollback.h>
+
 #include <QtGui/QGuiApplication>
 #include <QtGui/QWindow>
 #include <QtGui/QScreen>
@@ -119,6 +121,13 @@
 
 // -------------------------------------------------------------------------
 
+@interface QIOSViewController () {
+    QIOSScreen *m_screen;
+    BOOL m_updatingProperties;
+}
+@property (nonatomic, assign) BOOL changingOrientation;
+@end
+
 @implementation QIOSViewController
 
 - (id)initWithQIOSScreen:(QIOSScreen *)screen
@@ -147,6 +156,7 @@
 #endif
 
         self.changingOrientation = NO;
+        self.shouldAutorotate = [super shouldAutorotate];
 
         // Status bar may be initially hidden at startup through Info.plist
         self.prefersStatusBarHidden = infoPlistValue(@"UIStatusBarHidden", false);
@@ -173,6 +183,10 @@
     [center addObserver:self selector:@selector(willChangeStatusBarFrame:)
             name:UIApplicationWillChangeStatusBarFrameNotification
             object:[UIApplication sharedApplication]];
+
+    [center addObserver:self selector:@selector(didChangeStatusBarOrientation:)
+            name:UIApplicationDidChangeStatusBarOrientationNotification
+            object:[UIApplication sharedApplication]];
 }
 
 - (void)viewDidUnload
@@ -183,19 +197,16 @@
 
 // -------------------------------------------------------------------------
 
--(BOOL)shouldAutorotate
-{
-    // Until a proper orientation and rotation API is in place, we always auto rotate.
-    // If auto rotation is not wanted, you would need to switch it off manually from Info.plist.
-    return YES;
-}
-
 #if QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(__IPHONE_6_0)
 -(NSUInteger)supportedInterfaceOrientations
 {
-    // We need to tell iOS that we support all orientations in order to set
-    // status bar orientation when application content orientation changes.
-    return UIInterfaceOrientationMaskAll;
+    // As documented by Apple in the iOS 6.0 release notes, setStatusBarOrientation:animated:
+    // only works if the supportedInterfaceOrientations of the view controller is 0, making
+    // us responsible for ensuring that the status bar orientation is consistent. We enter
+    // this mode when auto-rotation is disabled due to an explicit content orientation being
+    // set on the focus window. Note that this is counter to what the documentation for
+    // supportedInterfaceOrientations says, which states that the method should not return 0.
+    return [self shouldAutorotate] ? UIInterfaceOrientationMaskAll : 0;
 }
 #endif
 
@@ -203,7 +214,7 @@
 -(BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
 {
     Q_UNUSED(interfaceOrientation);
-    return YES;
+    return [self shouldAutorotate];
 }
 #endif
 
@@ -250,6 +261,22 @@
     }];
 }
 
+- (void)didChangeStatusBarOrientation:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+
+    if (self.view.window.screen != [UIScreen mainScreen])
+        return;
+
+    // If the statusbar changes orientation due to auto-rotation we don't care,
+    // there will be re-layout anyways. Only if the statusbar changes due to
+    // reportContentOrientation, we need to update the window layout.
+    if (self.changingOrientation)
+        return;
+
+    [self.view setNeedsLayout];
+}
+
 - (void)viewWillLayoutSubviews
 {
     if (!QCoreApplication::instance())
@@ -265,6 +292,15 @@
     if (!isQtApplication())
         return;
 
+    // Prevent recursion caused by updating the status bar appearance (position
+    // or visibility), which in turn may cause a layout of our subviews, and
+    // a reset of window-states, which themselves affect the view controller
+    // properties such as the statusbar visibilty.
+    if (m_updatingProperties)
+        return;
+
+    QScopedValueRollback<BOOL> updateRollback(m_updatingProperties, YES);
+
     QWindow *focusWindow = QGuiApplication::focusWindow();
 
     // If we don't have a focus window we leave the statusbar
@@ -281,6 +317,8 @@
     // All decisions are based on the the top level window
     focusWindow = qt_window_private(focusWindow)->topLevelWindow();
 
+    UIApplication *uiApplication = [UIApplication sharedApplication];
+
     bool currentStatusBarVisibility = self.prefersStatusBarHidden;
     self.prefersStatusBarHidden = focusWindow->windowState() == Qt::WindowFullScreen;
 
@@ -291,13 +329,60 @@
         } else
 #endif
         {
-            [[UIApplication sharedApplication]
-                setStatusBarHidden:self.prefersStatusBarHidden
+            [uiApplication setStatusBarHidden:self.prefersStatusBarHidden
                 withAnimation:self.preferredStatusBarUpdateAnimation];
         }
 
         [self.view setNeedsLayout];
     }
+
+
+    // -------------- Content orientation ---------------
+
+    static BOOL kAnimateContentOrientationChanges = YES;
+
+    Qt::ScreenOrientation contentOrientation = focusWindow->contentOrientation();
+    if (contentOrientation != Qt::PrimaryOrientation) {
+        // An explicit content orientation has been reported for the focus window,
+        // so we keep the status bar in sync with content orientation. This will ensure
+        // that the task bar (and associated gestures) are also rotated accordingly.
+
+        if (self.shouldAutorotate) {
+            // We are moving from Qt::PrimaryOrientation to an explicit orientation,
+            // so we need to store the current statusbar orientation, as we need it
+            // later when mapping screen coordinates for QScreen and for returning
+            // to Qt::PrimaryOrientation.
+            self.lockedOrientation = uiApplication.statusBarOrientation;
+
+            // Calling setStatusBarOrientation only has an effect when auto-rotation is
+            // disabled, which makes sense when there's an explicit content orientation.
+            self.shouldAutorotate = NO;
+        }
+
+        [uiApplication setStatusBarOrientation:
+            UIInterfaceOrientation(fromQtScreenOrientation(contentOrientation))
+            animated:kAnimateContentOrientationChanges];
+
+    } else {
+        // The content orientation is set to Qt::PrimaryOrientation, meaning
+        // that auto-rotation should be enabled. But we may be coming out of
+        // a state of locked orientation, which needs some cleanup before we
+        // can enable auto-rotation again.
+        if (!self.shouldAutorotate) {
+            // First we need to restore the statusbar to what it was at the
+            // time of locking the orientation, otherwise iOS will be very
+            // confused when it starts doing auto-rotation again.
+            [uiApplication setStatusBarOrientation:
+                UIInterfaceOrientation(self.lockedOrientation)
+                animated:kAnimateContentOrientationChanges];
+
+            // Then we can re-enable auto-rotation
+            self.shouldAutorotate = YES;
+
+            // And finally let iOS rotate the root view to match the device orientation
+            [UIViewController attemptRotationToDeviceOrientation];
+        }
+    }
 }
 
 #if QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(__IPHONE_7_0)
diff --git a/src/plugins/platforms/ios/qioswindow.mm b/src/plugins/platforms/ios/qioswindow.mm
index 480062e4de..6c4614408d 100644
--- a/src/plugins/platforms/ios/qioswindow.mm
+++ b/src/plugins/platforms/ios/qioswindow.mm
@@ -75,6 +75,15 @@ QIOSWindow::QIOSWindow(QWindow *window)
 
     setWindowState(window->windowState());
     setOpacity(window->opacity());
+
+    Qt::ScreenOrientation initialOrientation = window->contentOrientation();
+    if (initialOrientation != Qt::PrimaryOrientation) {
+        // Start up in portrait, then apply possible content orientation,
+        // as per Apple's documentation.
+        dispatch_async(dispatch_get_main_queue(), ^{
+            handleContentOrientationChange(initialOrientation);
+        });
+    }
 }
 
 QIOSWindow::~QIOSWindow()
@@ -322,10 +331,12 @@ void QIOSWindow::updateWindowLevel()
 
 void QIOSWindow::handleContentOrientationChange(Qt::ScreenOrientation orientation)
 {
-    // Keep the status bar in sync with content orientation. This will ensure
-    // that the task bar (and associated gestures) are aligned correctly:
-    UIInterfaceOrientation uiOrientation = UIInterfaceOrientation(fromQtScreenOrientation(orientation));
-    [[UIApplication sharedApplication] setStatusBarOrientation:uiOrientation animated:NO];
+    // Update the QWindow representation straight away, so that
+    // we can update the statusbar orientation based on the new
+    // content orientation.
+    qt_window_private(window())->contentOrientation = orientation;
+
+    [m_view.qtViewController updateProperties];
 }
 
 void QIOSWindow::applicationStateChanged(Qt::ApplicationState)
diff --git a/src/plugins/platforms/windows/qwindowsdrag.cpp b/src/plugins/platforms/windows/qwindowsdrag.cpp
index fce60c3169..d3eb049269 100644
--- a/src/plugins/platforms/windows/qwindowsdrag.cpp
+++ b/src/plugins/platforms/windows/qwindowsdrag.cpp
@@ -626,7 +626,7 @@ QWindowsOleDropTarget::Drop(LPDATAOBJECT pDataObj, DWORD grfKeyState,
     const QPlatformDropQtResponse response =
         QWindowSystemInterface::handleDrop(m_window, windowsDrag->dropData(),
                                            m_lastPoint / QWindowsScaling::factor(),
-                                           translateToQDragDropActions(*pdwEffect));
+                                           translateToQDragDropActions(m_chosenEffect));
 
     if (response.isAccepted()) {
         const Qt::DropAction action = response.acceptedAction();
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
index 3058b29f2d..31dedd40a2 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
@@ -78,7 +78,8 @@ static int resourceType(const QByteArray &key)
         QByteArrayLiteral("startupid"), QByteArrayLiteral("traywindow"),
         QByteArrayLiteral("gettimestamp"), QByteArrayLiteral("x11screen"),
         QByteArrayLiteral("rootwindow"),
-        QByteArrayLiteral("subpixeltype"), QByteArrayLiteral("antialiasingEnabled")
+        QByteArrayLiteral("subpixeltype"), QByteArrayLiteral("antialiasingEnabled"),
+        QByteArrayLiteral("nofonthinting")
     };
     const QByteArray *end = names + sizeof(names) / sizeof(names[0]);
     const QByteArray *result = std::find(names, end, key);
@@ -283,6 +284,9 @@ void *QXcbNativeInterface::nativeResourceForScreen(const QByteArray &resource, Q
     case GetTimestamp:
         result = getTimestamp(xcbScreen);
         break;
+    case NoFontHinting:
+        result = xcbScreen->noFontHinting() ? this : 0; //qboolptr...
+        break;
     default:
         break;
     }
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.h b/src/plugins/platforms/xcb/qxcbnativeinterface.h
index b667f1a372..330dd008c4 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.h
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.h
@@ -67,7 +67,8 @@ public:
         X11Screen,
         RootWindow,
         ScreenSubpixelType,
-        ScreenAntialiasingEnabled
+        ScreenAntialiasingEnabled,
+        NoFontHinting
     };
 
     QXcbNativeInterface();
diff --git a/src/plugins/platforms/xcb/qxcbscreen.cpp b/src/plugins/platforms/xcb/qxcbscreen.cpp
index 8bdedba8ac..7136455754 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.cpp
+++ b/src/plugins/platforms/xcb/qxcbscreen.cpp
@@ -53,7 +53,7 @@ QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *scr,
     , m_screen(scr)
     , m_crtc(output ? output->crtc : 0)
     , m_outputName(outputName)
-    , m_sizeMillimeters(output ? QSize(output->mm_width, output->mm_height) : QSize())
+    , m_outputSizeMillimeters(output ? QSize(output->mm_width, output->mm_height) : QSize())
     , m_virtualSize(scr->width_in_pixels, scr->height_in_pixels)
     , m_virtualSizeMillimeters(scr->width_in_millimeters, scr->height_in_millimeters)
     , m_orientation(Qt::PrimaryOrientation)
@@ -62,6 +62,7 @@ QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *scr,
     , m_forcedDpi(-1)
     , m_devicePixelRatio(1)
     , m_hintStyle(QFontEngine::HintStyle(-1))
+    , m_noFontHinting(false)
     , m_subpixelType(QFontEngine::SubpixelAntialiasingType(-1))
     , m_antialiasingEnabled(-1)
     , m_xSettings(0)
@@ -71,18 +72,27 @@ QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *scr,
 
     updateGeometry(output ? output->timestamp : 0);
     updateRefreshRate();
+
     const int dpr = int(devicePixelRatio());
     // On VNC, it can be that physical size is unknown while
     // virtual size is known (probably back-calculated from DPI and resolution)
     if (m_sizeMillimeters.isEmpty())
         m_sizeMillimeters = m_virtualSizeMillimeters;
-    if (m_geometry.isEmpty())
+    if (m_geometry.isEmpty()) {
         m_geometry = QRect(QPoint(), m_virtualSize/dpr);
+        m_nativeGeometry = QRect(QPoint(), m_virtualSize);
+    }
     if (m_availableGeometry.isEmpty())
         m_availableGeometry = m_geometry;
 
     readXResources();
 
+    // disable font hinting when we do UI scaling
+    static bool dpr_scaling_enabled = (qgetenv("QT_DEVICE_PIXEL_RATIO").toInt() > 1
+                           || qgetenv("QT_DEVICE_PIXEL_RATIO").toLower() == "auto");
+    if (dpr_scaling_enabled)
+        m_noFontHinting = true;
+
 #ifdef Q_XCB_DEBUG
     qDebug();
     qDebug("Screen output %s of xcb screen %d:", m_outputName.toUtf8().constData(), m_number);
@@ -93,6 +103,7 @@ QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *scr,
     qDebug("  virtual height.: %lf", m_virtualSizeMillimeters.height());
     qDebug("  virtual geom...: %d x %d", m_virtualSize.width(), m_virtualSize.height());
     qDebug("  avail virt geom: %d x %d +%d +%d", m_availableGeometry.width(), m_availableGeometry.height(), m_availableGeometry.x(), m_availableGeometry.y());
+    qDebug("  orientation....: %d", m_orientation);
     qDebug("  pixel ratio....: %d", m_devicePixelRatio);
     qDebug("  depth..........: %d", screen()->root_depth);
     qDebug("  white pixel....: %x", screen()->white_pixel);
@@ -313,8 +324,14 @@ QDpi QXcbScreen::logicalDpi() const
     if (m_forcedDpi > 0)
         return QDpi(m_forcedDpi/dpr, m_forcedDpi/dpr);
 
-    return QDpi(Q_MM_PER_INCH * m_virtualSize.width() / m_virtualSizeMillimeters.width() / dpr,
-                Q_MM_PER_INCH * m_virtualSize.height() / m_virtualSizeMillimeters.height() / dpr);
+    static const bool auto_dpr = qgetenv("QT_DEVICE_PIXEL_RATIO").toLower() == "auto";
+    if (auto_dpr) {
+        return QDpi(Q_MM_PER_INCH * m_geometry.width() / m_sizeMillimeters.width(),
+                    Q_MM_PER_INCH * m_geometry.height() / m_sizeMillimeters.height());
+    } else {
+        return QDpi(Q_MM_PER_INCH * m_virtualSize.width() / m_virtualSizeMillimeters.width() / dpr,
+                    Q_MM_PER_INCH * m_virtualSize.height() / m_virtualSizeMillimeters.height() / dpr);
+    }
 }
 
 
@@ -413,6 +430,24 @@ void QXcbScreen::updateGeometry(xcb_timestamp_t timestamp)
         if (crtc) {
             xGeometry = QRect(crtc->x, crtc->y, crtc->width, crtc->height);
             xAvailableGeometry = xGeometry;
+            switch (crtc->rotation) {
+            case XCB_RANDR_ROTATION_ROTATE_0: // xrandr --rotate normal
+                m_orientation = Qt::LandscapeOrientation;
+                m_sizeMillimeters = m_outputSizeMillimeters;
+                break;
+            case XCB_RANDR_ROTATION_ROTATE_90: // xrandr --rotate left
+                m_orientation = Qt::PortraitOrientation;
+                m_sizeMillimeters = m_outputSizeMillimeters.transposed();
+                break;
+            case XCB_RANDR_ROTATION_ROTATE_180: // xrandr --rotate inverted
+                m_orientation = Qt::InvertedLandscapeOrientation;
+                m_sizeMillimeters = m_outputSizeMillimeters;
+                break;
+            case XCB_RANDR_ROTATION_ROTATE_270: // xrandr --rotate right
+                m_orientation = Qt::InvertedPortraitOrientation;
+                m_sizeMillimeters = m_outputSizeMillimeters.transposed();
+                break;
+            }
             free(crtc);
         }
     }
@@ -441,6 +476,7 @@ void QXcbScreen::updateGeometry(xcb_timestamp_t timestamp)
     m_devicePixelRatio = qRound(dpi/96);
     const int dpr = int(devicePixelRatio()); // we may override m_devicePixelRatio
     m_geometry = QRect(xGeometry.topLeft()/dpr, xGeometry.size()/dpr);
+    m_nativeGeometry = QRect(xGeometry.topLeft(), xGeometry.size());
     m_availableGeometry = QRect(xAvailableGeometry.topLeft()/dpr, xAvailableGeometry.size()/dpr);
 
     QWindowSystemInterface::handleScreenGeometryChange(QPlatformScreen::screen(), m_geometry, m_availableGeometry);
diff --git a/src/plugins/platforms/xcb/qxcbscreen.h b/src/plugins/platforms/xcb/qxcbscreen.h
index ca0aee2cc4..e9ab2edaa0 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.h
+++ b/src/plugins/platforms/xcb/qxcbscreen.h
@@ -62,6 +62,7 @@ public:
     QWindow *topLevelAt(const QPoint &point) const;
 
     QRect geometry() const { return m_geometry; }
+    QRect nativeGeometry() const { return m_nativeGeometry; }
     QRect availableGeometry() const {return m_availableGeometry;}
     int depth() const { return m_screen->root_depth; }
     QImage::Format format() const;
@@ -97,6 +98,7 @@ public:
     void readXResources();
 
     QFontEngine::HintStyle hintStyle() const { return m_hintStyle; }
+    bool noFontHinting() const { return m_noFontHinting; }
     QFontEngine::SubpixelAntialiasingType subpixelType() const { return m_subpixelType; }
     int antialiasingEnabled() const { return m_antialiasingEnabled; }
 
@@ -111,8 +113,10 @@ private:
     xcb_screen_t *m_screen;
     xcb_randr_crtc_t m_crtc;
     QString m_outputName;
+    QSizeF m_outputSizeMillimeters;
     QSizeF m_sizeMillimeters;
     QRect m_geometry;
+    QRect m_nativeGeometry;
     QRect m_availableGeometry;
     QSize m_virtualSize;
     QSizeF m_virtualSizeMillimeters;
@@ -129,6 +133,7 @@ private:
     int m_forcedDpi;
     int m_devicePixelRatio;
     QFontEngine::HintStyle m_hintStyle;
+    bool m_noFontHinting;
     QFontEngine::SubpixelAntialiasingType m_subpixelType;
     int m_antialiasingEnabled;
     QXcbXSettings *m_xSettings;
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index e1ccc3f086..4fd71f1635 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -151,7 +151,7 @@ static inline QRect mapToNative(const QRect &qtRect, int dpr)
     return QRect(qtRect.x() * dpr, qtRect.y() * dpr, qtRect.width() * dpr, qtRect.height() * dpr);
 }
 
-// When converting native rects to Qt rects: round top/left towards the origin and
+// When mapping expose events to Qt rects: round top/left towards the origin and
 // bottom/right away from the origin, making sure that we cover the whole widget
 
 static inline QPoint dpr_floor(const QPoint &p, int dpr)
@@ -164,11 +164,15 @@ static inline QPoint dpr_ceil(const QPoint &p, int dpr)
     return QPoint((p.x() + dpr - 1) / dpr, (p.y() + dpr - 1) / dpr);
 }
 
-static inline QRect mapFromNative(const QRect &xRect, int dpr)
+static inline QRect mapExposeFromNative(const QRect &xRect, int dpr)
 {
     return QRect(dpr_floor(xRect.topLeft(), dpr), dpr_ceil(xRect.bottomRight(), dpr));
 }
 
+static inline QRect mapGeometryFromNative(const QRect &xRect, int dpr)
+{
+    return QRect(xRect.topLeft() / dpr, xRect.bottomRight() / dpr);
+}
 
 // Returns \c true if we should set WM_TRANSIENT_FOR on \a w
 static inline bool isTransient(const QWindow *w)
@@ -1718,7 +1722,7 @@ public:
             return false;
         if (expose->count == 0)
             m_pending = false;
-        *m_region |= mapFromNative(QRect(expose->x, expose->y, expose->width, expose->height), m_dpr);
+        *m_region |= mapExposeFromNative(QRect(expose->x, expose->y, expose->width, expose->height), m_dpr);
         return true;
     }
 
@@ -1746,7 +1750,7 @@ void QXcbWindow::handleExposeEvent(const xcb_expose_event_t *event)
 {
     const int dpr = int(devicePixelRatio());
     QRect x_rect(event->x, event->y, event->width, event->height);
-    QRect rect = mapFromNative(x_rect, dpr);
+    QRect rect = mapExposeFromNative(x_rect, dpr);
 
     if (m_exposeRegion.isEmpty())
         m_exposeRegion = rect;
@@ -1831,6 +1835,23 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
     }
 }
 
+// Temporary workaround for bug in QPlatformScreen::screenForNativeGeometry
+// we need the native geometries to detect our screen, but that's not
+// available in cross-platform code. Will be fixed properly when highDPI
+// support is refactored to expose the native coordinate system.
+
+QPlatformScreen *QXcbWindow::screenForNativeGeometry(const QRect &newGeometry) const
+{
+    QXcbScreen *currentScreen = static_cast<QXcbScreen*>(screen());
+    if (!parent() && !currentScreen->nativeGeometry().intersects(newGeometry)) {
+        Q_FOREACH (QPlatformScreen* screen, currentScreen->virtualSiblings()) {
+            if (static_cast<QXcbScreen*>(screen)->nativeGeometry().intersects(newGeometry))
+                return screen;
+        }
+    }
+    return currentScreen;
+}
+
 void QXcbWindow::handleConfigureNotifyEvent(const xcb_configure_notify_event_t *event)
 {
     bool fromSendEvent = (event->response_type & 0x80);
@@ -1847,15 +1868,23 @@ void QXcbWindow::handleConfigureNotifyEvent(const xcb_configure_notify_event_t *
         }
     }
 
-    QRect rect = mapFromNative(QRect(pos, QSize(event->width, event->height)), int(devicePixelRatio()));
+    const int dpr = devicePixelRatio();
+    const QRect nativeRect = QRect(pos, QSize(event->width, event->height));
+    const QRect rect = mapGeometryFromNative(nativeRect, dpr);
 
     QPlatformWindow::setGeometry(rect);
     QWindowSystemInterface::handleGeometryChange(window(), rect);
 
-    QPlatformScreen *newScreen = screenForGeometry(rect);
+    QPlatformScreen *newScreen = screenForNativeGeometry(nativeRect);
     if (newScreen != m_screen) {
         m_screen = static_cast<QXcbScreen*>(newScreen);
         QWindowSystemInterface::handleWindowScreenChanged(window(), newScreen->screen());
+        int newDpr = devicePixelRatio();
+        if (newDpr != dpr) {
+            QRect newRect = mapGeometryFromNative(nativeRect, newDpr);
+            QPlatformWindow::setGeometry(newRect);
+            QWindowSystemInterface::handleGeometryChange(window(), newRect);
+        }
     }
 
     m_configureNotifyPending = false;
diff --git a/src/plugins/platforms/xcb/qxcbwindow.h b/src/plugins/platforms/xcb/qxcbwindow.h
index 12d20d004d..254421e57d 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.h
+++ b/src/plugins/platforms/xcb/qxcbwindow.h
@@ -154,6 +154,8 @@ public:
 
     qreal devicePixelRatio() const;
 
+    QPlatformScreen *screenForNativeGeometry(const QRect &newGeometry) const;
+
 public Q_SLOTS:
     void updateSyncRequestCounter();
 
diff --git a/src/plugins/platforms/xcb/qxcbxsettings.cpp b/src/plugins/platforms/xcb/qxcbxsettings.cpp
index 13d42832db..a1dadb0e54 100644
--- a/src/plugins/platforms/xcb/qxcbxsettings.cpp
+++ b/src/plugins/platforms/xcb/qxcbxsettings.cpp
@@ -36,7 +36,9 @@
 #include <QtCore/QByteArray>
 #include <QtCore/QtEndian>
 
+#ifdef XCB_USE_XLIB
 #include <X11/extensions/XIproto.h>
+#endif //XCB_USE_XLIB
 
 QT_BEGIN_NAMESPACE
 /* Implementation of http://standards.freedesktop.org/xsettings-spec/xsettings-0.5.html */
@@ -138,6 +140,7 @@ public:
         return value + 4 - remainder;
     }
 
+#ifdef XCB_USE_XLIB
     void populateSettings(const QByteArray &xSettings)
     {
         if (xSettings.length() < 12)
@@ -212,6 +215,7 @@ public:
         }
 
     }
+#endif //XCB_USE_XLIB
 
     QXcbScreen *screen;
     xcb_window_t x_settings_window;
@@ -258,8 +262,10 @@ QXcbXSettings::QXcbXSettings(QXcbScreen *screen)
     const uint32_t event_mask[] = { XCB_EVENT_MASK_STRUCTURE_NOTIFY|XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_change_window_attributes(screen->xcb_connection(),d_ptr->x_settings_window,event,event_mask);
 
+#ifdef XCB_USE_XLIB
     d_ptr->populateSettings(d_ptr->getSettings());
     d_ptr->initialized = true;
+#endif //XCB_USE_XLIB
 }
 
 QXcbXSettings::~QXcbXSettings()
@@ -279,7 +285,9 @@ void QXcbXSettings::handlePropertyNotifyEvent(const xcb_property_notify_event_t
     Q_D(QXcbXSettings);
     if (event->window != d->x_settings_window)
         return;
+#ifdef XCB_USE_XLIB
     d->populateSettings(d->getSettings());
+#endif //XCB_USE_XLIB
 }
 
 void QXcbXSettings::registerCallbackForProperty(const QByteArray &property, QXcbXSettings::PropertyChangeFunc func, void *handle)