Merge lp:~unity-team/qtubuntu/screen-info into lp:qtubuntu

[Gerry Boland]

Dynamic scaling support

[lp:~unity-team/qtubuntu/screen-info]

312. By Gerry Boland on 2016-02-03

Merge trunk

313. By Gerry Boland on 2016-02-03

Drop the new changelog entry

314. By Gerry Boland on 2016-02-03

Fix comment, resolve build error

315. By Gerry Boland on 2016-02-03

Bad weave merge, fix duplicate line

316. By Gerry Boland on 2016-02-03

Fix another compile error, type mistake

317. By Gerry Boland on 2016-02-11

Do not flush window system events in QPlatformWindow::setVisible, can crash during screen changes

318. By Gerry Boland on 2016-02-11

Experimental refactor, to keep ScreenObserver isolated from Qt state handling

319. By Gerry Boland on 2016-02-15

Add per-Screen property change signal and getter for the custom properties scale & formfactor

320. By Gerry Boland on 2016-02-15

Safer float to void* casting

321. By Gerry Boland on 2016-02-15

Change getter of custom Screen properties, return pointer to float, instead of shoving float into pointer. Nicer for apps

322. By Michał Sawicz on 2016-02-17

Merge lp:~nick-dedekind/qtubuntu/shell_chrome

323. By Nick Dedekind on 2016-02-17

merge bugs

324. By Nick Dedekind on 2016-02-17

dont update on expose

325. By Gerry Boland on 2016-02-17

Fix for build fail

326. By Nick Dedekind on 2016-02-18

fixed crash from event handling before constructor completed.

327. By Nick Dedekind on 2016-02-18

merged with parent

328. By Nick Dedekind on 2016-02-18

remerge

329. By Michał Sawicz on 2016-04-20

Merge trunk

Unmerged revisions

329. By Michał Sawicz on 2016-04-20

Merge trunk

328. By Nick Dedekind on 2016-02-18

remerge

327. By Nick Dedekind on 2016-02-18

merged with parent

=== modified file 'src/ubuntumirclient/backingstore.cpp'
--- src/ubuntumirclient/backingstore.cpp	2014-12-04 12:29:39 +0000
+++ src/ubuntumirclient/backingstore.cpp	2016-02-17 14:37:36 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License version 3, as published by
@@ -43,8 +43,10 @@
 {
     Q_UNUSED(region);
     Q_UNUSED(offset);
+    const int dpr = int(window->devicePixelRatio());
+
     mContext->makeCurrent(window);
-    glViewport(0, 0, window->width(), window->height());
+    glViewport(0, 0, window->width() * dpr, window->height() * dpr);
 
     updateTexture();
 
@@ -75,12 +77,14 @@
 
     QRegion fixed;
     QRect imageRect = mImage.rect();
+    const int dpr = int(window()->devicePixelRatio());
 
-    /* Following code taken from QEGLPlatformBackingStore under the terms of the Lesser GPL v2.1 licence
+    /* Following code a modified form of that in QEGLPlatformBackingStore, used under the terms of the Lesser GPL v2.1 licence
      * Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). */
     Q_FOREACH (const QRect &rect, mDirty.rects()) {
+        QRect scaledRect(rect.topLeft() * dpr, rect.size() * dpr);
         // intersect with image rect to be sure
-        QRect r = imageRect & rect;
+        QRect r = imageRect & scaledRect;
 
         // if the rect is wide enough it is cheaper to just extend it instead of doing an image copy
         if (r.width() >= imageRect.width() / 2) {
@@ -115,7 +119,9 @@
 
 void UbuntuBackingStore::resize(const QSize& size, const QRegion& /*staticContents*/)
 {
-    mImage = QImage(size, QImage::Format_RGB32);
+    const int dpr = int(window()->devicePixelRatio());
+    mImage = QImage(size * dpr, QImage::Format_RGB32);
+    mImage.setDevicePixelRatio(dpr);
 
     if (mTexture->isCreated())
         mTexture->destroy();

=== modified file 'src/ubuntumirclient/input.cpp'
--- src/ubuntumirclient/input.cpp	2016-02-02 11:07:38 +0000
+++ src/ubuntumirclient/input.cpp	2016-02-17 14:37:36 +0000
@@ -38,6 +38,9 @@
 
 Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntumirclient.input", QtWarningMsg)
 
+namespace
+{
+
 // XKB Keysyms which do not map directly to Qt types (i.e. Unicode points)
 static const uint32_t KeyTable[] = {
     XKB_KEY_Escape,                  Qt::Key_Escape,
@@ -118,6 +121,26 @@
     0,                          0
 };
 
+Qt::WindowState mirSurfaceStateToWindowState(MirSurfaceState state)
+{
+    switch (state) {
+    case mir_surface_state_fullscreen:
+        return Qt::WindowFullScreen;
+    case mir_surface_state_maximized:
+    case mir_surface_state_vertmaximized:
+    case mir_surface_state_horizmaximized:
+        return Qt::WindowMaximized;
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        return Qt::WindowMinimized;
+    default:
+    case mir_surface_state_restored:
+        return Qt::WindowNoState;
+    }
+}
+
+}
+
 class UbuntuEvent : public QEvent
 {
 public:
@@ -176,6 +199,8 @@
         return "mir_event_type_close_surface";
     case mir_event_type_input:
         return "mir_event_type_input";
+    case mir_event_type_surface_output:
+        return "mir_event_type_surface_output";
     default:
         return "invalid";
     }
@@ -211,43 +236,26 @@
         break;
     case mir_event_type_resize:
     {
-        Q_ASSERT(ubuntuEvent->window->screen() == mIntegration->screen());
-
         auto resizeEvent = mir_event_get_resize_event(nativeEvent);
 
-        mIntegration->screen()->handleWindowSurfaceResize(
-                mir_resize_event_get_width(resizeEvent),
-                mir_resize_event_get_height(resizeEvent));
+        // Enable workaround for Screen rotation
+        auto screen = static_cast<UbuntuScreen*>(ubuntuEvent->window->screen());
+        if (screen) {
+            screen->handleWindowSurfaceResize(
+                    mir_resize_event_get_width(resizeEvent),
+                    mir_resize_event_get_height(resizeEvent));
+        }
 
         ubuntuEvent->window->handleSurfaceResized(mir_resize_event_get_width(resizeEvent),
             mir_resize_event_get_height(resizeEvent));
         break;
     }
     case mir_event_type_surface:
-    {
-        auto surfaceEvent = mir_event_get_surface_event(nativeEvent);
-        if (mir_surface_event_get_attribute(surfaceEvent) == mir_surface_attrib_focus) {
-            const bool focused = mir_surface_event_get_attribute_value(surfaceEvent) == mir_surface_focused;
-            // Mir may have sent a pair of focus lost/gained events, so we need to "peek" into the queue
-            // so that we don't deactivate windows prematurely.
-            if (focused) {
-                mPendingFocusGainedEvents--;
-                ubuntuEvent->window->handleSurfaceFocused();
-                QWindowSystemInterface::handleWindowActivated(ubuntuEvent->window->window(), Qt::ActiveWindowFocusReason);
-
-                // NB: Since processing of system events is queued, never check qGuiApp->applicationState()
-                //     as it might be outdated. Always call handleApplicationStateChanged() with the latest
-                //     state regardless.
-                QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
-
-            } else if(!mPendingFocusGainedEvents) {
-                qCDebug(ubuntumirclient, "No windows have focus");
-                QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
-                QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
-            }
-        }
-        break;
-    }
+        handleSurfaceEvent(ubuntuEvent->window, mir_event_get_surface_event(nativeEvent));
+        break;
+    case mir_event_type_surface_output:
+        handleSurfaceOutputEvent(ubuntuEvent->window, mir_event_get_surface_output_event(nativeEvent));
+        break;
     case mir_event_type_orientation:
         dispatchOrientationEvent(ubuntuEvent->window->window(), mir_event_get_orientation_event(nativeEvent));
         break;
@@ -312,6 +320,7 @@
     const QRect kWindowGeometry = window->geometry();
     QList<QWindowSystemInterface::TouchPoint> touchPoints;
 
+    const int dpr = int(window->devicePixelRatio());
 
     // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
     //       as Qt::TouchPointMoved
@@ -319,10 +328,10 @@
     for (unsigned int i = 0; i < kPointerCount; ++i) {
         QWindowSystemInterface::TouchPoint touchPoint;
 
-        const float kX = mir_touch_event_axis_value(tev, i, mir_touch_axis_x) + kWindowGeometry.x();
-        const float kY = mir_touch_event_axis_value(tev, i, mir_touch_axis_y) + kWindowGeometry.y(); // see bug lp:1346633 workaround comments elsewhere
-        const float kW = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major);
-        const float kH = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor);
+        const float kX = mir_touch_event_axis_value(tev, i, mir_touch_axis_x) / dpr + kWindowGeometry.x();
+        const float kY = mir_touch_event_axis_value(tev, i, mir_touch_axis_y) / dpr + kWindowGeometry.y(); // see bug lp:1346633 workaround comments elsewhere
+        const float kW = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major) / dpr;
+        const float kH = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor) / dpr;
         const float kP = mir_touch_event_axis_value(tev, i, mir_touch_axis_pressure);
         touchPoint.id = mir_touch_event_id(tev, i);
         touchPoint.normalPosition = QPointF(kX / kWindowGeometry.width(), kY / kWindowGeometry.height());
@@ -456,14 +465,16 @@
 
 void UbuntuInput::dispatchPointerEvent(UbuntuWindow *platformWindow, const MirInputEvent *ev)
 {
-    auto window = platformWindow->window();
-    auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
-
-    auto pev = mir_input_event_get_pointer_event(ev);
-    auto action = mir_pointer_event_action(pev);
-    auto localPoint = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_x),
-                              mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
-    auto modifiers = qt_modifiers_from_mir(mir_pointer_event_modifiers(pev));
+    const int dpr = int(platformWindow->devicePixelRatio());
+    const auto window = platformWindow->window();
+    const auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
+
+    const auto pev = mir_input_event_get_pointer_event(ev);
+    const auto action = mir_pointer_event_action(pev);
+
+    const auto modifiers = qt_modifiers_from_mir(mir_pointer_event_modifiers(pev));
+    const auto localPoint = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_x) / dpr,
+                              mir_pointer_event_axis_value(pev, mir_pointer_axis_y) / dpr);
 
     switch (action) {
     case mir_pointer_action_button_up:
@@ -551,3 +562,68 @@
                                 new OrientationChangeEvent(OrientationChangeEvent::mType, orientation));
 }
 
+void UbuntuInput::handleSurfaceEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceEvent *event)
+{
+    auto surfaceEventAttribute = mir_surface_event_get_attribute(event);
+
+    switch (surfaceEventAttribute) {
+    case mir_surface_attrib_focus: {
+        const bool focused = mir_surface_event_get_attribute_value(event) == mir_surface_focused;
+        // Mir may have sent a pair of focus lost/gained events, so we need to "peek" into the queue
+        // so that we don't deactivate windows prematurely.
+        if (focused) {
+            mPendingFocusGainedEvents--;
+            window->handleSurfaceFocused();
+            QWindowSystemInterface::handleWindowActivated(window->window(), Qt::ActiveWindowFocusReason);
+
+            // NB: Since processing of system events is queued, never check qGuiApp->applicationState()
+            //     as it might be outdated. Always call handleApplicationStateChanged() with the latest
+            //     state regardless.
+            QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
+
+        } else if(!mPendingFocusGainedEvents) {
+            qCDebug(ubuntumirclient, "No windows have focus");
+            QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
+            QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
+        }
+        break;
+    }
+    case mir_surface_attrib_visibility:
+        window->handleSurfaceExposeChange(
+                    mir_surface_event_get_attribute_value(event) == mir_surface_visibility_exposed);
+        break;
+    // Remaining attributes are ones client sets for server, and server should not override them
+    case mir_surface_attrib_state:
+        MirSurfaceState state = static_cast<MirSurfaceState>(mir_surface_event_get_attribute_value(surfaceEvent));
+        ubuntuEvent->window->handleSurfaceStateChanged(mirSurfaceStateToWindowState(state));
+        break;
+    case mir_surface_attrib_type:
+    case mir_surface_attrib_swapinterval:
+    case mir_surface_attrib_dpi:
+    case mir_surface_attrib_preferred_orientation:
+    case mir_surface_attribs:
+        break;
+    }
+}
+
+void UbuntuInput::handleSurfaceOutputEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceOutputEvent *event)
+{
+    const uint32_t outputId = mir_surface_output_event_get_output_id(event);
+    const int dpi = mir_surface_output_event_get_dpi(event);
+    const MirFormFactor formFactor = mir_surface_output_event_get_form_factor(event);
+    const float scale = mir_surface_output_event_get_scale(event);
+
+    const auto screenObserver = mIntegration->screenObserver();
+    UbuntuScreen *screen = screenObserver->findScreenWithId(outputId);
+    if (!screen) {
+        qWarning() << "Mir notified window" << window->window() << "on an unknown screen with id" << outputId;
+        return;
+    }
+
+    screenObserver->handleScreenPropertiesChange(screen, dpi, formFactor, scale);
+    window->handleScreenPropertiesChange(formFactor, scale);
+
+    if (window->screen() != screen) {
+        QWindowSystemInterface::handleWindowScreenChanged(window->window(), screen->screen());
+    }
+}

=== modified file 'src/ubuntumirclient/input.h'
--- src/ubuntumirclient/input.h	2015-12-09 13:02:07 +0000
+++ src/ubuntumirclient/input.h	2016-02-17 14:37:36 +0000
@@ -49,6 +49,8 @@
     void dispatchInputEvent(UbuntuWindow *window, const MirInputEvent *event);
 
     void dispatchOrientationEvent(QWindow* window, const MirOrientationEvent *event);
+    void handleSurfaceEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceEvent *event);
+    void handleSurfaceOutputEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceOutputEvent *event);
 
 private:
     UbuntuClientIntegration* mIntegration;

=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2016-01-04 17:18:51 +0000
+++ src/ubuntumirclient/integration.cpp	2016-02-17 14:37:36 +0000
@@ -88,19 +88,26 @@
                "rejected the incoming connection, so check its log file");
 
     mNativeInterface->setMirConnection(u_application_instance_get_mir_connection(mInstance));
-
-    // Create default screen.
-    mScreen = new UbuntuScreen(u_application_instance_get_mir_connection(mInstance));
-    screenAdded(mScreen);
+}
+
+void UbuntuClientIntegration::initialize()
+{
+    MirConnection *mirConnection = u_application_instance_get_mir_connection(mInstance);
+
+    // Init the ScreenObserver
+    mScreenObserver.reset(new UbuntuScreenObserver(mirConnection));
+    connect(mScreenObserver.data(), &UbuntuScreenObserver::screenAdded,
+            [this](UbuntuScreen *screen) { this->screenAdded(screen); });
+    connect(mScreenObserver.data(), &UbuntuScreenObserver::screenRemoved,
+                     this, &UbuntuClientIntegration::destroyScreen);
+
+    Q_FOREACH(auto screen, mScreenObserver->screens()) {
+        screenAdded(screen);
+    }
 
     // Initialize input.
-    if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_INPUT")) {
-        mInput = new UbuntuInput(this);
-        mInputContext = QPlatformInputContextFactory::create();
-    } else {
-        mInput = nullptr;
-        mInputContext = nullptr;
-    }
+    mInput = new UbuntuInput(this);
+    mInputContext = QPlatformInputContextFactory::create();
 
     // compute the scale factor
     const int defaultGridUnit = 8;
@@ -120,7 +127,6 @@
 {
     delete mInput;
     delete mInputContext;
-    delete mScreen;
     delete mServices;
 }
 
@@ -165,8 +171,8 @@
 
 QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window)
 {
-    return new UbuntuWindow(window, mClipboard, static_cast<UbuntuScreen*>(mScreen),
-                            mInput, u_application_instance_get_mir_connection(mInstance));
+    return new UbuntuWindow(window, mClipboard, mInput, mNativeInterface,
+                            u_application_instance_get_mir_connection(mInstance));
 }
 
 bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
@@ -262,3 +268,34 @@
 {
     return new UbuntuOffscreenSurface(surface);
 }
+
+void UbuntuClientIntegration::destroyScreen(UbuntuScreen *screen)
+{
+    // FIXME: on deleting a screen while a Window is on it, Qt will automatically
+    // move the window to the primaryScreen(). This will trigger a screenChanged
+    // signal, causing things like QQuickScreenAttached to re-fetch screen properties
+    // like DPI and physical size. However this is crashing, as Qt is calling virtual
+    // functions on QPlatformScreen, for reasons unclear. As workaround, move window
+    // to primaryScreen() before deleting the screen. Might be QTBUG-38650
+
+    QScreen *primaryScreen = QGuiApplication::primaryScreen();
+    if (screen != primaryScreen->handle()) {
+        uint32_t movedWindowCount = 0;
+        Q_FOREACH (QWindow *w, QGuiApplication::topLevelWindows()) {
+            if (w->screen()->handle() == screen) {
+                QWindowSystemInterface::handleWindowScreenChanged(w, primaryScreen);
+                ++movedWindowCount;
+            }
+        }
+        if (movedWindowCount > 0) {
+            QWindowSystemInterface::flushWindowSystemEvents();
+        }
+    }
+
+    qDebug() << "Removing Screen with id" << screen->outputId() << "and geometry" << screen->geometry();
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
+    delete screen;
+#else
+    this->destroyScreen(screen);
+#endif
+}

=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2016-01-04 17:18:51 +0000
+++ src/ubuntumirclient/integration.h	2016-02-17 14:37:36 +0000
@@ -21,6 +21,7 @@
 #include <QSharedPointer>
 
 #include "platformservices.h"
+#include "screenobserver.h"
 
 // platform-api
 #include <ubuntu/application/description.h>
@@ -31,7 +32,10 @@
 class UbuntuNativeInterface;
 class UbuntuScreen;
 
-class UbuntuClientIntegration : public QPlatformIntegration {
+class UbuntuClientIntegration : public QObject, public QPlatformIntegration
+{
+    Q_OBJECT
+
 public:
     UbuntuClientIntegration();
     virtual ~UbuntuClientIntegration();
@@ -53,10 +57,15 @@
 
     QPlatformOpenGLContext* createPlatformOpenGLContext(QOpenGLContext* context);
     QPlatformWindow* createPlatformWindow(QWindow* window);
-    UbuntuScreen* screen() const { return mScreen; }
+    UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
+
+    void initialize() override;
 
     QPlatformOffscreenSurface *createPlatformOffscreenSurface(QOffscreenSurface *surface) const override;
 
+private Q_SLOTS:
+    void destroyScreen(UbuntuScreen *screen);
+
 private:
     void setupOptions();
     void setupDescription();
@@ -66,10 +75,10 @@
 
     UbuntuPlatformServices* mServices;
 
-    UbuntuScreen* mScreen;
     UbuntuInput* mInput;
     QPlatformInputContext* mInputContext;
     QSharedPointer<UbuntuClipboard> mClipboard;
+    QScopedPointer<UbuntuScreenObserver> mScreenObserver;
     qreal mScaleFactor;
 
     // Platform API stuff

=== modified file 'src/ubuntumirclient/nativeinterface.cpp'
--- src/ubuntumirclient/nativeinterface.cpp	2015-12-15 16:16:06 +0000
+++ src/ubuntumirclient/nativeinterface.cpp	2016-02-17 14:37:36 +0000
@@ -18,6 +18,7 @@
 #include "nativeinterface.h"
 #include "screen.h"
 #include "glcontext.h"
+#include "window.h"
 
 // Qt
 #include <private/qguiapplication_p.h>
@@ -35,6 +36,8 @@
         insert("nativeorientation", UbuntuNativeInterface::NativeOrientation);
         insert("display", UbuntuNativeInterface::Display);
         insert("mirconnection", UbuntuNativeInterface::MirConnection);
+        insert("scale", UbuntuNativeInterface::Scale);
+        insert("formfactor", UbuntuNativeInterface::FormFactor);
     }
 };
 
@@ -123,10 +126,59 @@
     if (!ubuntuResourceMap()->contains(kLowerCaseResource))
         return NULL;
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
+    if (!screen)
+        screen = QGuiApplication::primaryScreen();
+    auto ubuntuScreen = static_cast<UbuntuScreen*>(screen->handle());
     if (kResourceType == UbuntuNativeInterface::Display) {
-        if (!screen)
-            screen = QGuiApplication::primaryScreen();
-        return static_cast<UbuntuScreen*>(screen->handle())->eglNativeDisplay();
+        return ubuntuScreen->eglNativeDisplay();
+    // Changes to the following properties are emitted via the UbuntuNativeInterface::screenPropertyChanged
+    // signal fired by UbuntuScreen. Connect to this signal for these properties updates.
+    // WARNING: code highly thread unsafe!
+    } else if (kResourceType == UbuntuNativeInterface::Scale) {
+        // In application code, read with:
+        //    float scale = *reinterpret_cast<float*>(nativeResourceForScreen("scale", screen()));
+        return &ubuntuScreen->mScale;
+    } else if (kResourceType == UbuntuNativeInterface::FormFactor) {
+        return &ubuntuScreen->mFormFactor;
     } else
         return NULL;
 }
+
+// Changes to these properties are emitted via the UbuntuNativeInterface::windowPropertyChanged
+// signal fired by UbuntuWindow. Connect to this signal for these properties updates.
+QVariantMap UbuntuNativeInterface::windowProperties(QPlatformWindow *window) const
+{
+    QVariantMap propertyMap;
+    auto w = static_cast<UbuntuWindow*>(window);
+    if (w) {
+        propertyMap.insert("scale", w->scale());
+        propertyMap.insert("formFactor", w->formFactor());
+    }
+    return propertyMap;
+}
+
+QVariant UbuntuNativeInterface::windowProperty(QPlatformWindow *window, const QString &name) const
+{
+    auto w = static_cast<UbuntuWindow*>(window);
+    if (!w) {
+        return QVariant();
+    }
+
+    if (name == QStringLiteral("scale")) {
+        return w->scale();
+    } else if (name == QStringLiteral("formFactor")) {
+        return w->formFactor();
+    } else {
+        return QVariant();
+    }
+}
+
+QVariant UbuntuNativeInterface::windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const
+{
+    QVariant returnVal = windowProperty(window, name);
+    if (!returnVal.isValid()) {
+        return defaultValue;
+    } else {
+        return returnVal;
+    }
+}

=== modified file 'src/ubuntumirclient/nativeinterface.h'
--- src/ubuntumirclient/nativeinterface.h	2015-08-27 09:41:47 +0000
+++ src/ubuntumirclient/nativeinterface.h	2016-02-17 14:37:36 +0000
@@ -19,9 +19,12 @@
 
 #include <qpa/qplatformnativeinterface.h>
 
+class QPlatformScreen;
+
 class UbuntuNativeInterface : public QPlatformNativeInterface {
+    Q_OBJECT
 public:
-    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection };
+    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection, Scale, FormFactor };
 
     UbuntuNativeInterface();
     ~UbuntuNativeInterface();
@@ -35,10 +38,17 @@
     void* nativeResourceForScreen(const QByteArray& resourceString,
                                   QScreen* screen) override;
 
+    QVariantMap windowProperties(QPlatformWindow *window) const override;
+    QVariant windowProperty(QPlatformWindow *window, const QString &name) const override;
+    QVariant windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const override;
+
     // New methods.
     const QByteArray& genericEventFilterType() const { return mGenericEventFilterType; }
     void setMirConnection(void *mirConnection) { mMirConnection = mirConnection; }
 
+Q_SIGNALS: // New signals
+    void screenPropertyChanged(QPlatformScreen *screen, const QString &propertyName);
+
 private:
     const QByteArray mGenericEventFilterType;
     Qt::ScreenOrientation* mNativeOrientation;

=== modified file 'src/ubuntumirclient/screen.cpp'
--- src/ubuntumirclient/screen.cpp	2015-12-09 13:01:28 +0000
+++ src/ubuntumirclient/screen.cpp	2016-02-17 14:37:36 +0000
@@ -18,11 +18,13 @@
 #include "screen.h"
 #include "logging.h"
 #include "orientationchangeevent_p.h"
+#include "nativeinterface.h"
+#include "utils.h"
 
 #include <mir_toolkit/mir_client_library.h>
 
 // Qt
-#include <QCoreApplication>
+#include <QGuiApplication>
 #include <QtCore/qmath.h>
 #include <QScreen>
 #include <QThread>
@@ -101,37 +103,29 @@
     }
 }
 
+namespace {
+    int qGetEnvIntValue(const char *varName, bool *ok)
+    {
+        return qgetenv(varName).toInt(ok);
+    }
+} // anonymous namespace
+
+
 const QEvent::Type OrientationChangeEvent::mType =
         static_cast<QEvent::Type>(QEvent::registerEventType());
 
-static const MirDisplayOutput *find_active_output(
-    const MirDisplayConfiguration *conf)
-{
-    const MirDisplayOutput *output = NULL;
-    for (uint32_t d = 0; d < conf->num_outputs; d++)
-    {
-        const MirDisplayOutput *out = conf->outputs + d;
-
-        if (out->used &&
-            out->connected &&
-            out->num_modes &&
-            out->current_mode < out->num_modes)
-        {
-            output = out;
-            break;
-        }
-    }
-
-    return output;
-}
-
-UbuntuScreen::UbuntuScreen(MirConnection *connection)
-    : mFormat(QImage::Format_RGB32)
+
+UbuntuScreen::UbuntuScreen(const MirDisplayOutput &output, MirConnection *connection)
+    : mDevicePixelRatio(1.0)
+    , mFormat(QImage::Format_RGB32)
     , mDepth(32)
+    , mDpi{0}
+    , mFormFactor{mir_form_factor_unknown}
+    , mScale{1.0}
     , mOutputId(0)
-    , mSurfaceFormat()
     , mEglDisplay(EGL_NO_DISPLAY)
     , mEglConfig(nullptr)
+    , mSurfaceFormat()
     , mCursor(connection)
 {
     // Initialize EGL.
@@ -164,45 +158,15 @@
     }
 
     // Set vblank swap interval.
-    int swapInterval = kSwapInterval;
-    QByteArray swapIntervalString = qgetenv("QTUBUNTU_SWAPINTERVAL");
-    if (!swapIntervalString.isEmpty()) {
-        bool ok;
-        swapInterval = swapIntervalString.toInt(&ok);
-        if (!ok)
-            swapInterval = kSwapInterval;
-    }
-    qCDebug(ubuntumirclient, "setting swap interval to %d", swapInterval);
+    bool ok;
+    int swapInterval = qGetEnvIntValue("QTUBUNTU_SWAPINTERVAL", &ok);
+    if (!ok)
+        swapInterval = kSwapInterval;
+
+    qCDebug(ubuntumirclient, "Setting swap interval to %d", swapInterval);
     eglSwapInterval(mEglDisplay, swapInterval);
 
-    // Get screen resolution.
-    auto configDeleter = [](MirDisplayConfiguration *config) { mir_display_config_destroy(config); };
-    using configUp = std::unique_ptr<MirDisplayConfiguration, decltype(configDeleter)>;
-    configUp displayConfig(mir_connection_create_display_config(connection), configDeleter);
-    ASSERT(displayConfig != nullptr);
-
-    auto const displayOutput = find_active_output(displayConfig.get());
-    ASSERT(displayOutput != nullptr);
-
-    mOutputId = displayOutput->output_id;
-
-    mPhysicalSize = QSizeF(displayOutput->physical_width_mm, displayOutput->physical_height_mm);
-    qCDebug(ubuntumirclient, "screen physical size: %.2fx%.2f", mPhysicalSize.width(), mPhysicalSize.height());
-
-    const MirDisplayMode *mode = &displayOutput->modes[displayOutput->current_mode];
-    const int kScreenWidth = mode->horizontal_resolution;
-    const int kScreenHeight = mode->vertical_resolution;
-    Q_ASSERT(kScreenWidth > 0 && kScreenHeight > 0);
-
-    qCDebug(ubuntumirclient, "screen resolution: %dx%d", kScreenWidth, kScreenHeight);
-
-    mGeometry = QRect(0, 0, kScreenWidth, kScreenHeight);
-
-    // Set the default orientation based on the initial screen dimmensions.
-    mNativeOrientation = (mGeometry.width() >= mGeometry.height()) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
-
-    // If it's a landscape device (i.e. some tablets), start in landscape, otherwise portrait
-    mCurrentOrientation = (mNativeOrientation == Qt::LandscapeOrientation) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
+    setMirDisplayOutput(output);
 }
 
 UbuntuScreen::~UbuntuScreen()
@@ -278,3 +242,77 @@
         QWindowSystemInterface::handleScreenOrientationChange(screen(), mCurrentOrientation);
     }
 }
+
+void UbuntuScreen::setMirDisplayOutput(const MirDisplayOutput &output)
+{
+    // Physical screen size
+    mPhysicalSize.setWidth(output.physical_width_mm);
+    mPhysicalSize.setHeight(output.physical_height_mm);
+
+    // Pixel Format
+//    mFormat = qImageFormatFromMirPixelFormat(output.current_format); // GERRY: TODO
+
+    // Pixel depth
+    mDepth = 8 * MIR_BYTES_PER_PIXEL(output.current_format);
+
+    // Mode = Resolution & refresh rate
+    MirDisplayMode mode = output.modes[output.current_mode];
+    mNativeGeometry.setX(output.position_x);
+    mNativeGeometry.setY(output.position_y);
+    mNativeGeometry.setWidth(mode.horizontal_resolution);
+    mNativeGeometry.setHeight(mode.vertical_resolution);
+    mRefreshRate = mode.refresh_rate;
+
+    // geometry in device pixels
+    mGeometry.setX(mNativeGeometry.x() / mDevicePixelRatio);
+    mGeometry.setY(mNativeGeometry.y() / mDevicePixelRatio);
+    mGeometry.setWidth(mNativeGeometry.width() / mDevicePixelRatio);
+    mGeometry.setHeight(mNativeGeometry.height() / mDevicePixelRatio);
+
+    // Misc
+//    mScale = output.scale; // missing from MirDisplayOutput, wait for later setAdditionalMirDisplayProperties call
+//    mFormFactor = output.form_factor; // ditto
+    mOutputId = output.output_id;
+
+    // Set the default orientation based on the initial screen dimmensions.
+    mNativeOrientation = (mGeometry.width() >= mGeometry.height()) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
+
+    // If it's a landscape device (i.e. some tablets), start in landscape, otherwise portrait
+    mCurrentOrientation = (mNativeOrientation == Qt::LandscapeOrientation) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
+}
+
+void UbuntuScreen::setAdditionalMirDisplayProperties(float scale, MirFormFactor formFactor, float dpi)
+{
+    auto nativeInterface = static_cast<UbuntuNativeInterface *>(qGuiApp->platformNativeInterface());
+    if (!qFuzzyCompare(mScale, scale)) {
+        mScale = scale;
+        Q_EMIT nativeInterface->screenPropertyChanged(this, QStringLiteral("scale"));
+    }
+    if (mFormFactor != formFactor) {
+        mFormFactor = formFactor;
+        Q_EMIT nativeInterface->screenPropertyChanged(this, QStringLiteral("formFactor"));
+    }
+
+    bool ok;
+    int dpr = qGetEnvIntValue("QT_DEVICE_PIXEL_RATIO", &ok);
+    if (ok && dpr > 0) {
+        qCDebug(ubuntumirclient, "Fixing Device Pixel Ratio to %d", dpr);
+        mDevicePixelRatio = dpr;
+    } else {
+        mDevicePixelRatio = 1.0; //qCeil(scale); // FIXME - unable to announce change in this until can delete/recreate Screen.
+    }
+
+    if (mDpi != dpi) {
+        mDpi = dpi;
+        QWindowSystemInterface::handleScreenLogicalDotsPerInchChange(screen(), dpi, dpi);
+    }
+}
+
+QDpi UbuntuScreen::logicalDpi() const
+{
+    if (mDpi > 0) {
+        return QDpi(mDpi, mDpi);
+    } else {
+        return QPlatformScreen::logicalDpi();
+    }
+}

=== modified file 'src/ubuntumirclient/screen.h'
--- src/ubuntumirclient/screen.h	2015-11-23 11:10:24 +0000
+++ src/ubuntumirclient/screen.h	2016-02-17 14:37:36 +0000
@@ -19,17 +19,21 @@
 
 #include <qpa/qplatformscreen.h>
 #include <QSurfaceFormat>
+
+#include <mircommon/mir_toolkit/common.h> // just for MirFormFactor enum
+
 #include <EGL/egl.h>
 
 #include "cursor.h"
 
 struct MirConnection;
+struct MirDisplayOutput;
 
 class UbuntuScreen : public QObject, public QPlatformScreen
 {
     Q_OBJECT
 public:
-    UbuntuScreen(MirConnection *connection);
+    UbuntuScreen(const MirDisplayOutput &output, MirConnection *connection);
     virtual ~UbuntuScreen();
 
     // QPlatformScreen methods.
@@ -38,6 +42,8 @@
     QRect geometry() const override { return mGeometry; }
     QRect availableGeometry() const override { return mGeometry; }
     QSizeF physicalSize() const override { return mPhysicalSize; }
+    qreal devicePixelRatio() const override { return mDevicePixelRatio; }
+    QDpi logicalDpi() const override;
     Qt::ScreenOrientation nativeOrientation() const override { return mNativeOrientation; }
     Qt::ScreenOrientation orientation() const override { return mNativeOrientation; }
     QPlatformCursor *cursor() const override { return const_cast<UbuntuCursor*>(&mCursor); }
@@ -47,6 +53,15 @@
     EGLDisplay eglDisplay() const { return mEglDisplay; }
     EGLConfig eglConfig() const { return mEglConfig; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
+
+    // Additional Screen properties from Mir
+    uint32_t outputId() const { return mOutputId; }
+    MirFormFactor formFactor() const { return mFormFactor; }
+    float scale() const { return mScale; }
+
+    // Internally used methods
+    void setMirDisplayOutput(const MirDisplayOutput &output);
+    void setAdditionalMirDisplayProperties(float scale, MirFormFactor formFactor, float dpi);
     void handleWindowSurfaceResize(int width, int height);
     uint32_t mirOutputId() const { return mOutputId; }
 
@@ -54,18 +69,25 @@
     void customEvent(QEvent* event) override;
 
 private:
-    QRect mGeometry;
+    QRect mGeometry, mNativeGeometry;
     QSizeF mPhysicalSize;
+    qreal mDevicePixelRatio;
     Qt::ScreenOrientation mNativeOrientation;
     Qt::ScreenOrientation mCurrentOrientation;
     QImage::Format mFormat;
     int mDepth;
+    int mDpi;
+    qreal mRefreshRate;
+    MirFormFactor mFormFactor;
+    float mScale;
     uint32_t mOutputId;
-    QSurfaceFormat mSurfaceFormat;
     EGLDisplay mEglDisplay;
     EGLConfig mEglConfig;
     EGLNativeDisplayType mEglNativeDisplay;
-    UbuntuCursor mCursor;
+    QSurfaceFormat mSurfaceFormat;
+    UbuntuCursor mCursor; //GERRY try const
+
+    friend class UbuntuNativeInterface;
 };
 
 #endif // UBUNTU_SCREEN_H

=== added file 'src/ubuntumirclient/screenobserver.cpp'
--- src/ubuntumirclient/screenobserver.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/screenobserver.cpp	2016-02-17 14:37:36 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "screenobserver.h"
+#include "screen.h"
+#include "window.h"
+#include "logging.h"
+
+// Qt
+#include <QMetaObject>
+#include <QPointer>
+
+// Mir
+#include <mirclient/mir_toolkit/mir_connection.h>
+
+#include <memory>
+
+namespace {
+    static void displayConfigurationChangedCallback(MirConnection */*connection*/, void* context)
+    {
+        ASSERT(context != NULL);
+        UbuntuScreenObserver *observer = static_cast<UbuntuScreenObserver *>(context);
+        QMetaObject::invokeMethod(observer, "update");
+    }
+} // anonymous namespace
+
+UbuntuScreenObserver::UbuntuScreenObserver(MirConnection *mirConnection)
+    : mMirConnection(mirConnection)
+{
+    mir_connection_set_display_config_change_callback(mirConnection, ::displayConfigurationChangedCallback, this);
+    update();
+}
+
+void UbuntuScreenObserver::update()
+{
+    // Wrap MirDisplayConfiguration to always delete when out of scope
+    auto configDeleter = [](MirDisplayConfiguration *config) { mir_display_config_destroy(config); };
+    using configUp = std::unique_ptr<MirDisplayConfiguration, decltype(configDeleter)>;
+    configUp displayConfig(mir_connection_create_display_config(mMirConnection), configDeleter);
+
+    // Mir only tells us something changed, it is up to us to figure out what.
+    QList<UbuntuScreen*> newScreenList;
+    QList<UbuntuScreen*> oldScreenList = mScreenList;
+    mScreenList.clear();
+
+    for (uint32_t i=0; i<displayConfig->num_outputs; i++) {
+        MirDisplayOutput output = displayConfig->outputs[i];
+        if (output.used && output.connected) {
+            UbuntuScreen *screen = findScreenWithId(oldScreenList, output.output_id);
+            if (screen) { // we've already set up this display before, refresh its internals
+                screen->setMirDisplayOutput(output);
+                oldScreenList.removeAll(screen);
+            } else {
+                // new display, so create UbuntuScreen for it
+                screen = new UbuntuScreen(output, mMirConnection);
+                newScreenList.append(screen);
+                qDebug() << "Added Screen with id" << output.output_id << "and geometry" << screen->geometry();
+            }
+            mScreenList.append(screen);
+        }
+    }
+
+    // Announce old & unused Screens, should be deleted by the slot
+    Q_FOREACH (const auto screen, oldScreenList) {
+        Q_EMIT screenRemoved(screen);
+    }
+
+    /*
+     * Mir's MirDisplayOutput does not include formFactor or scale for some reason, but Qt
+     * will want that information on creating the QScreen. Only way we get that info is when
+     * Mir positions a Window on that Screen. See "handleScreenPropertiesChange" method
+     */
+
+    // Announce new Screens
+    Q_FOREACH (const auto screen, newScreenList) {
+        Q_EMIT screenAdded(screen);
+    }
+
+    qDebug() << "=======================================";
+    for (auto screen: mScreenList) {
+        qDebug() << screen << "- id:" << screen->outputId()
+                           << "geometry:" << screen->geometry()
+                           << "form factor:" << screen->formFactor()
+                           << "scale:" << screen->scale();
+    }
+    qDebug() << "=======================================";
+}
+
+UbuntuScreen *UbuntuScreenObserver::findScreenWithId(uint32_t id)
+{
+    return findScreenWithId(mScreenList, id);
+}
+
+UbuntuScreen *UbuntuScreenObserver::findScreenWithId(const QList<UbuntuScreen *> &list, uint32_t id)
+{
+    Q_FOREACH (const auto screen, list) {
+        if (screen->outputId() == id) {
+            return screen;
+        }
+    }
+    return nullptr;
+}
+
+void UbuntuScreenObserver::handleScreenPropertiesChange(UbuntuScreen *screen, int dpi,
+                                                        MirFormFactor formFactor, float scale)
+{
+    screen->setAdditionalMirDisplayProperties(scale, formFactor, dpi);
+
+    qDebug() << "=======================================";
+    for (auto screen: mScreenList) {
+        qDebug() << screen << "- id:" << screen->outputId()
+                           << "geometry:" << screen->geometry()
+                           << "form factor:" << screen->formFactor()
+                           << "scale:" << screen->scale();
+    }
+    qDebug() << "=======================================";
+}
+

=== added file 'src/ubuntumirclient/screenobserver.h'
--- src/ubuntumirclient/screenobserver.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/screenobserver.h	2016-02-17 14:37:36 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTU_SCREEN_OBSERVER_H
+#define UBUNTU_SCREEN_OBSERVER_H
+
+#include <QObject>
+
+#include <mir_toolkit/mir_connection.h>
+
+class UbuntuScreen;
+
+class UbuntuScreenObserver : public QObject
+{
+    Q_OBJECT
+
+public:
+    UbuntuScreenObserver(MirConnection *connection);
+
+    QList<UbuntuScreen*> screens() const { return mScreenList; }
+    UbuntuScreen *findScreenWithId(uint32_t id);
+
+    void handleScreenPropertiesChange(UbuntuScreen *screen, int dpi,
+                                      MirFormFactor formFactor, float scale);
+
+Q_SIGNALS:
+    void screenAdded(UbuntuScreen *screen);
+    void screenRemoved(UbuntuScreen *screen);
+
+private Q_SLOTS:
+    void update();
+
+private:
+    UbuntuScreen *findScreenWithId(const QList<UbuntuScreen *> &list, uint32_t id);
+    void removeScreen(UbuntuScreen *screen);
+
+    MirConnection *mMirConnection;
+    QList<UbuntuScreen*> mScreenList;
+};
+
+#endif // UBUNTU_SCREEN_OBSERVER_H

=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2016-01-04 17:18:51 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2016-02-17 14:37:36 +0000
@@ -26,6 +26,7 @@
     platformservices.cpp \
     plugin.cpp \
     screen.cpp \
+    screenobserver.cpp \
     theme.cpp \
     window.cpp
 
@@ -42,9 +43,11 @@
     orientationchangeevent_p.h \
     platformservices.h \
     plugin.h \
+    screenobserver.h \
     screen.h \
     theme.h \
-    window.h
+    window.h \
+    utils.h
 
 # Installation path
 target.path +=  $$[QT_INSTALL_PLUGINS]/platforms

=== added file 'src/ubuntumirclient/utils.h'
--- src/ubuntumirclient/utils.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/utils.h	2016-02-17 14:37:36 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <QtGlobal>
+
+namespace {
+    inline int divideAndRoundUp(int numerator, qreal denominator)
+    {
+        return ceil((qreal)numerator / denominator);
+    }
+} // anonymous namespace
+
+#endif // UTILS_H

=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2016-02-02 11:07:38 +0000
+++ src/ubuntumirclient/window.cpp	2016-02-17 14:37:36 +0000
@@ -17,8 +17,10 @@
 // Local
 #include "window.h"
 #include "clipboard.h"
+#include "nativeinterface.h"
 #include "input.h"
 #include "screen.h"
+#include "utils.h"
 #include "logging.h"
 
 #include <mir_toolkit/mir_client_library.h>
@@ -34,8 +36,15 @@
 
 #include <EGL/egl.h>
 
+
+/*
+ * Note: all geometry is in device-independent pixels, except that contained in variables with the
+ * suffix "Px" - whose units are (physical) pixels
+ */
 Q_LOGGING_CATEGORY(ubuntumirclientBufferSwap, "ubuntumirclient.bufferSwap", QtWarningMsg)
 
+const Qt::WindowType WindowHidesShellDecorations = (Qt::WindowType)0x00800000;
+
 namespace
 {
 
@@ -65,23 +74,6 @@
     return reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(stream));
 }
 
-MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
-{
-    switch (state) {
-    case Qt::WindowNoState:
-        return mir_surface_state_restored;
-    case Qt::WindowFullScreen:
-        return mir_surface_state_fullscreen;
-    case Qt::WindowMaximized:
-        return mir_surface_state_maximized;
-    case Qt::WindowMinimized:
-        return mir_surface_state_minimized;
-    default:
-        qCWarning(ubuntumirclient, "Unexpected Qt::WindowState: %d", state);
-        return mir_surface_state_restored;
-    }
-}
-
 const char *qtWindowStateToStr(Qt::WindowState state)
 {
     switch (state) {
@@ -93,11 +85,45 @@
         return "Maximized";
     case Qt::WindowMinimized:
         return "Minimized";
+    case Qt::WindowActive:
+        return "Active";
     default:
         return "!?";
     }
 }
 
+const char *mirSurfaceStateToStr(MirSurfaceState surfaceState)
+{
+    switch (surfaceState) {
+    case mir_surface_state_unknown: return "unknown";
+    case mir_surface_state_restored: return "restored";
+    case mir_surface_state_minimized: return "minimized";
+    case mir_surface_state_maximized: return "vertmaximized";
+    case mir_surface_state_vertmaximized: return "vertmaximized";
+    case mir_surface_state_fullscreen: return "fullscreen";
+    case mir_surface_state_horizmaximized: return "horizmaximized";
+    case mir_surface_state_hidden: return "hidden";
+    default: return "!?";
+    }
+}
+
+MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
+{
+    switch (state) {
+    case Qt::WindowNoState:
+        return mir_surface_state_restored;
+    case Qt::WindowFullScreen:
+        return mir_surface_state_fullscreen;
+    case Qt::WindowMaximized:
+        return mir_surface_state_maximized;
+    case Qt::WindowMinimized:
+        return mir_surface_state_minimized;
+    default:
+        qCWarning(ubuntumirclient, "Unexpected Qt::WindowState: %d", state);
+        return mir_surface_state_restored;
+    }
+}
+
 WId makeId()
 {
     static int id = 1;
@@ -134,13 +160,14 @@
 Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirConnection *connection)
 {
     const auto geom = window->geometry();
-    const int width = geom.width() > 0 ? geom.width() : 1;
-    const int height = geom.height() > 0 ? geom.height() : 1;
+    const int dpr = int(window->devicePixelRatio());
+    const int widthPx = geom.width() > 0 ? geom.width() * dpr : 1;
+    const int heightPx = geom.height() > 0 ? geom.height() * dpr : 1;
     const auto pixelFormat = defaultPixelFormatFor(connection);
 
     if (U_ON_SCREEN_KEYBOARD_ROLE == roleFor(window)) {
-        qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating input method surface (width=%d, height=%d", window, width, height);
-        return Spec{mir_connection_create_spec_for_input_method(connection, width, height, pixelFormat)};
+        qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating input method surface with size=(%dx%d)px", window, widthPx, heightPx);
+        return Spec{mir_connection_create_spec_for_input_method(connection, widthPx, heightPx, pixelFormat)};
     }
 
     const Qt::WindowType type = window->type();
@@ -153,13 +180,13 @@
             parent = input->lastFocusedWindow();
         }
         if (parent) {
-            auto pos = geom.topLeft();
-            pos -= parent->geometry().topLeft();
-            MirRectangle location{pos.x(), pos.y(), 0, 0};
-            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating menu surface(width:%d, height:%d)", window, width, height);
+            auto posPx = geom.topLeft() * dpr;
+            posPx -= parent->geometry().topLeft() * dpr;
+            MirRectangle location{posPx.x(), posPx.y(), 0, 0};
+            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating menu surface with size=(%dx%d)px", window, widthPx, heightPx);
             return Spec{mir_connection_create_spec_for_menu(
-                    connection, width, height, pixelFormat, parent->mirSurface(),
-                    &location, mir_edge_attachment_any)};
+                        connection, widthPx, heightPx, pixelFormat, parent->mirSurface(),
+                        &location, mir_edge_attachment_any)};
         } else {
             qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - cannot create a menu without a parent!", window);
         }
@@ -167,37 +194,39 @@
         auto parent = transientParentFor(window);
         if (parent) {
             // Modal dialog
-            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating modal dialog (width=%d, height=%d", window, width, height);
-            return Spec{mir_connection_create_spec_for_modal_dialog(connection, width, height, pixelFormat, parent->mirSurface())};
+            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating modal dialog with size=(%dx%d)px", window, widthPx, heightPx);
+            return Spec{mir_connection_create_spec_for_modal_dialog(connection, widthPx, heightPx, pixelFormat, parent->mirSurface())};
         } else {
             // TODO: do Qt parentless dialogs have the same semantics as mir?
-            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating parentless dialog (width=%d, height=%d)", window, width, height);
-            return Spec{mir_connection_create_spec_for_dialog(connection, width, height, pixelFormat)};
+            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating parentless dialog with size=(%dx%d)px", window, widthPx, heightPx);
+            return Spec{mir_connection_create_spec_for_dialog(connection, widthPx, heightPx, pixelFormat)};
         }
     }
-    qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating normal surface(type=0x%x, width=%d, height=%d)", window, type, width, height);
-    return Spec{mir_connection_create_spec_for_normal_surface(connection, width, height, pixelFormat)};
+    qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating normal surface(type=0x%x, with size=(%dx%d)px", window, type, widthPx, heightPx);
+    return Spec{mir_connection_create_spec_for_normal_surface(connection, widthPx, heightPx, pixelFormat)};
 }
 
-void setSizingConstraints(MirSurfaceSpec *spec, const QSize& minSize, const QSize& maxSize, const QSize& increment)
+void setSizingConstraints(MirSurfaceSpec *spec, const QSize &minSizePx, const QSize &maxSizePx, const QSize &incrementPx)
 {
-    mir_surface_spec_set_min_width(spec, minSize.width());
-    mir_surface_spec_set_min_height(spec, minSize.height());
-    if (maxSize.width() >= minSize.width()) {
-        mir_surface_spec_set_max_width(spec, maxSize.width());
-    }
-    if (maxSize.height() >= minSize.height()) {
-        mir_surface_spec_set_max_height(spec, maxSize.height());
-    }
-    if (increment.width() > 0) {
-        mir_surface_spec_set_width_increment(spec, increment.width());
-    }
-    if (increment.height() > 0) {
-        mir_surface_spec_set_height_increment(spec, increment.height());
+    mir_surface_spec_set_min_width(spec, minSizePx.width());
+    mir_surface_spec_set_min_height(spec, minSizePx.height());
+    if (maxSizePx.width() >= minSizePx.width()) {
+        mir_surface_spec_set_max_width(spec, maxSizePx.width());
+    }
+    if (maxSizePx.height() >= minSizePx.height()) {
+        mir_surface_spec_set_max_height(spec, maxSizePx.height());
+    }
+    if (incrementPx.width() > 0) {
+        mir_surface_spec_set_width_increment(spec, incrementPx.width());
+    }
+    if (incrementPx.height() > 0) {
+        mir_surface_spec_set_height_increment(spec, incrementPx.height());
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, UbuntuScreen *screen, UbuntuInput *input, MirConnection *connection)
+MirSurface *createMirSurface(QWindow *window, UbuntuScreen *screen, UbuntuInput *input,
+                             MirConnection *connection, mir_surface_event_callback inputCallback,
+                             void* inputContext)
 {
     auto spec = makeSurfaceSpec(window, input, connection);
     const auto title = window->title().toUtf8();
@@ -209,6 +238,12 @@
         mir_surface_spec_set_fullscreen_on_output(spec.get(), screen->mirOutputId());
     }
 
+    mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
+
+    if (window->flags() & WindowHidesShellDecorations) {
+        mir_surface_spec_set_shell_chrome(spec.get(), mir_shell_chrome_low);
+    }
+
     auto surface = mir_surface_create_sync(spec.get());
     Q_ASSERT(mir_surface_is_valid(surface));
     return surface;
@@ -233,6 +268,10 @@
 
 } //namespace
 
+/*
+ * UbuntuSurface - wraps a MirSurface
+ * All units are in pixels only (no device pixels).
+ */
 class UbuntuSurface
 {
 public:
@@ -241,38 +280,26 @@
         , mPlatformWindow(platformWindow)
         , mInput(input)
         , mConnection(connection)
-        , mMirSurface(createMirSurface(mWindow, screen, input, connection))
+        , mMirSurface(createMirSurface(mWindow, screen, input, connection, surfaceEventCallback, this))
         , mEglDisplay(screen->eglDisplay())
         , mEglSurface(eglCreateWindowSurface(mEglDisplay, screen->eglConfig(), nativeWindowFor(mMirSurface), nullptr))
-        , mVisible(false)
         , mNeedsRepaint(false)
         , mParented(mWindow->transientParent() || mWindow->parent())
         , mWindowState(mWindow->windowState())
-
+        , mShellChrome(mWindow->flags() & WindowHidesShellDecorations ? mir_shell_chrome_low : mir_shell_chrome_normal)
     {
-        mir_surface_set_event_handler(mMirSurface, surfaceEventCallback, this);
-
         // Window manager can give us a final size different from what we asked for
         // so let's check what we ended up getting
         MirSurfaceParameters parameters;
         mir_surface_get_parameters(mMirSurface, &parameters);
 
-        auto geom = mWindow->geometry();
-        geom.setWidth(parameters.width);
-        geom.setHeight(parameters.height);
-        if (mWindowState == Qt::WindowFullScreen) {
-            geom.setY(0);
-        } else {
-            geom.setY(panelHeight());
-        }
-
         // Assume that the buffer size matches the surface size at creation time
-        mBufferSize = geom.size();
-        platformWindow->QPlatformWindow::setGeometry(geom);
-        QWindowSystemInterface::handleGeometryChange(mWindow, geom);
+        mBufferSizePx.rwidth() = parameters.width;
+        mBufferSizePx.rheight() = parameters.height;
 
-        qCDebug(ubuntumirclient, "created surface at (%d, %d) with size (%d, %d), title '%s', role: '%d'\n",
-             geom.x(), geom.y(), geom.width(), geom.height(), mWindow->title().toUtf8().constData(), roleFor(mWindow));
+        qCDebug(ubuntumirclient, "created surface with size=(%dx%d)px, title='%s', role=%d",
+                parameters.width, parameters.height, qPrintable(mWindow->title()), roleFor(mWindow));
+        mPlatformWindow->updateWindowSize(parameters.width, parameters.height);
     }
 
     ~UbuntuSurface()
@@ -283,26 +310,32 @@
             mir_surface_release_sync(mMirSurface);
     }
 
-    UbuntuSurface(UbuntuSurface const&) = delete;
-    UbuntuSurface& operator=(UbuntuSurface const&) = delete;
+    UbuntuSurface(const UbuntuSurface &) = delete;
+    UbuntuSurface& operator=(const UbuntuSurface &) = delete;
 
-    void resize(const QSize& newSize);
-    void setState(Qt::WindowState newState);
-    void setVisible(bool state);
-    void updateTitle(const QString& title);
-    void setSizingConstraints(const QSize& minSize, const QSize& maxSize, const QSize& increment);
+    void resize(const QSize &newSizePx);
+    void updateTitle(const QString &title);
+    void setSizingConstraints(const QSize &minSizePx, const QSize &maxSizePx, const QSize &incrementPx);
 
     void onSwapBuffersDone();
-    void handleSurfaceResized(int width, int height);
+    void handleSurfaceResized(int widthPx, int heightPx);
     int needsRepaint() const;
 
+    MirSurfaceState state() const { return mir_surface_get_state(mMirSurface); }
+    void setState(MirSurfaceState state);
+
+    MirSurfaceType type() const { return mir_surface_get_type(mMirSurface); }
+
+    void setShellChrome(MirShellChrome shellChrome);
+
     EGLSurface eglSurface() const { return mEglSurface; }
     MirSurface *mirSurface() const { return mMirSurface; }
 
+    void updateSurface();
+
 private:
-    static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);
+    static void surfaceEventCallback(MirSurface *surface, const MirEvent *event, void *context);
     void postEvent(const MirEvent *event);
-    void updateSurface();
 
     QWindow * const mWindow;
     UbuntuWindow * const mPlatformWindow;
@@ -313,59 +346,36 @@
     const EGLDisplay mEglDisplay;
     const EGLSurface mEglSurface;
 
-    bool mVisible;
     bool mNeedsRepaint;
     bool mParented;
-    Qt::WindowState mWindowState;
-    QSize mBufferSize;
+    QSize mBufferSizePx;
 
     QMutex mTargetSizeMutex;
-    QSize mTargetSize;
+    QSize mTargetSizePx;
+    MirShellChrome mShellChrome;
 };
 
-void UbuntuSurface::resize(const QSize& size)
+void UbuntuSurface::resize(const QSize &sizePx)
 {
-    qCDebug(ubuntumirclient,"resize(window=%p, width=%d, height=%d)", mWindow, size.width(), size.height());
+    qCDebug(ubuntumirclient,"resize(window=%p) to (%dx%d)px", mWindow, sizePx.width(), sizePx.height());
 
-    if (mWindowState == Qt::WindowFullScreen || mWindowState == Qt::WindowMaximized) {
+    if (mWindow->windowState() == Qt::WindowFullScreen || mWindow->windowState() == Qt::WindowMaximized) {
         qCDebug(ubuntumirclient, "resize(window=%p) - not resizing, window is maximized or fullscreen", mWindow);
         return;
     }
 
-    if (size.isEmpty()) {
+    if (sizePx.isEmpty()) {
         qCDebug(ubuntumirclient, "resize(window=%p) - not resizing, size is empty", mWindow);
         return;
     }
 
     Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    mir_surface_spec_set_width(spec.get(), size.width());
-    mir_surface_spec_set_height(spec.get(), size.height());
+    mir_surface_spec_set_width(spec.get(), sizePx.width());
+    mir_surface_spec_set_height(spec.get(), sizePx.height());
     mir_surface_apply_spec(mMirSurface, spec.get());
 }
 
-void UbuntuSurface::setState(Qt::WindowState newState)
-{
-    mir_wait_for(mir_surface_set_state(mMirSurface, qtWindowStateToMirSurfaceState(newState)));
-    mWindowState = newState;
-}
-
-void UbuntuSurface::setVisible(bool visible)
-{
-    if (mVisible == visible)
-        return;
-
-    mVisible = visible;
-
-    if (mVisible)
-        updateSurface();
-
-    // TODO: Use the new mir_surface_state_hidden state instead of mir_surface_state_minimized.
-    //       Will have to change qtmir and unity8 for that.
-    const auto newState = visible ? qtWindowStateToMirSurfaceState(mWindowState) : mir_surface_state_minimized;
-    mir_wait_for(mir_surface_set_state(mMirSurface, newState));
-}
-
-void UbuntuSurface::updateTitle(const QString& newTitle)
+void UbuntuSurface::updateTitle(const QString &newTitle)
 {
     const auto title = newTitle.toUtf8();
     Spec spec{mir_connection_create_spec_for_changes(mConnection)};
@@ -373,14 +383,14 @@
     mir_surface_apply_spec(mMirSurface, spec.get());
 }
 
-void UbuntuSurface::setSizingConstraints(const QSize& minSize, const QSize& maxSize, const QSize& increment)
+void UbuntuSurface::setSizingConstraints(const QSize &minSizePx, const QSize &maxSizePx, const QSize &incrementPx)
 {
     Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    ::setSizingConstraints(spec.get(), minSize, maxSize, increment);
+    ::setSizingConstraints(spec.get(), minSizePx, maxSizePx, incrementPx);
     mir_surface_apply_spec(mMirSurface, spec.get());
 }
 
-void UbuntuSurface::handleSurfaceResized(int width, int height)
+void UbuntuSurface::handleSurfaceResized(int widthPx, int heightPx)
 {
     QMutexLocker lock(&mTargetSizeMutex);
 
@@ -390,13 +400,13 @@
     // see TODO in postEvent as the ideal way we should handle this.
     // The actual buffer size may or may have not changed at this point, so let the rendering
     // thread drive the window geometry updates.
-    mNeedsRepaint = mTargetSize.width() == width && mTargetSize.height() == height;
+    mNeedsRepaint = mTargetSizePx.width() == widthPx && mTargetSizePx.height() == heightPx;
 }
 
 int UbuntuSurface::needsRepaint() const
 {
     if (mNeedsRepaint) {
-        if (mTargetSize != mBufferSize) {
+        if (mTargetSizePx != mBufferSizePx) {
             //If the buffer hasn't changed yet, we need at least two redraws,
             //once to get the new buffer size and propagate the geometry changes
             //and the second to redraw the content at the new size
@@ -410,34 +420,46 @@
     return 0;
 }
 
+void UbuntuSurface::setState(MirSurfaceState state)
+{
+    mir_wait_for(mir_surface_set_state(mMirSurface, state));
+}
+
+void UbuntuSurface::setShellChrome(MirShellChrome chrome)
+{
+    if (chrome != mShellChrome) {
+        auto spec = Spec{mir_connection_create_spec_for_changes(mConnection)};
+        mir_surface_spec_set_shell_chrome(spec.get(), chrome);
+        mir_surface_apply_spec(mMirSurface, spec.get());
+
+        mShellChrome = chrome;
+    }
+}
+
 void UbuntuSurface::onSwapBuffersDone()
 {
     static int sFrameNumber = 0;
     ++sFrameNumber;
 
-    EGLint eglSurfaceWidth = -1;
-    EGLint eglSurfaceHeight = -1;
-    eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &eglSurfaceWidth);
-    eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &eglSurfaceHeight);
-
-    const bool validSize = eglSurfaceWidth > 0 && eglSurfaceHeight > 0;
-
-    if (validSize && (mBufferSize.width() != eglSurfaceWidth || mBufferSize.height() != eglSurfaceHeight)) {
-
-        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - size changed (%d, %d) => (%d, %d)",
-               mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height(), eglSurfaceWidth, eglSurfaceHeight);
-
-        mBufferSize.rwidth() = eglSurfaceWidth;
-        mBufferSize.rheight() = eglSurfaceHeight;
-
-        QRect newGeometry = mPlatformWindow->geometry();
-        newGeometry.setSize(mBufferSize);
-
-        mPlatformWindow->QPlatformWindow::setGeometry(newGeometry);
-        QWindowSystemInterface::handleGeometryChange(mWindow, newGeometry);
+    EGLint eglSurfaceWidthPx = -1;
+    EGLint eglSurfaceHeightPx = -1;
+    eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &eglSurfaceWidthPx);
+    eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &eglSurfaceHeightPx);
+
+    const bool validSize = eglSurfaceWidthPx > 0 && eglSurfaceHeightPx > 0;
+
+    if (validSize && (mBufferSizePx.width() != eglSurfaceWidthPx || mBufferSizePx.height() != eglSurfaceHeightPx)) {
+
+        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size changed (%dx%d)px => (%dx%d)px",
+                mWindow, sFrameNumber, mBufferSizePx.width(), mBufferSizePx.height(), eglSurfaceWidthPx, eglSurfaceHeightPx);
+
+        mBufferSizePx.rwidth() = eglSurfaceWidthPx;
+        mBufferSizePx.rheight() = eglSurfaceHeightPx;
+
+        mPlatformWindow->updateWindowSize(eglSurfaceWidthPx, eglSurfaceHeightPx);
     } else {
-        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size (%d,%d)",
-               mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height());
+        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size=(%dx%d)px",
+                mWindow, sFrameNumber, mBufferSizePx.width(), mBufferSizePx.height());
     }
 }
 
@@ -458,13 +480,13 @@
         // As a workaround, we use the width/height as an identifier of this latest event
         // so the event handler (handleSurfaceResized) can discard/ignore old ones.
         const auto resizeEvent = mir_event_get_resize_event(event);
-        const auto width =  mir_resize_event_get_width(resizeEvent);
-        const auto height =  mir_resize_event_get_height(resizeEvent);
-        qCDebug(ubuntumirclient, "resizeEvent(window=%p, width=%d, height=%d)", mWindow, width, height);
+        const auto widthPx = mir_resize_event_get_width(resizeEvent);
+        const auto heightPx = mir_resize_event_get_height(resizeEvent);
+        qCDebug(ubuntumirclient, "resizeEvent(window=%p, size=(%dx%d)px", mWindow, widthPx, heightPx);
 
         QMutexLocker lock(&mTargetSizeMutex);
-        mTargetSize.rwidth() = width;
-        mTargetSize.rheight() = height;
+        mTargetSizePx.rwidth() = widthPx;
+        mTargetSizePx.rheight() = heightPx;
     }
 
     mInput->postEvent(mPlatformWindow, event);
@@ -488,15 +510,22 @@
     }
 }
 
-UbuntuWindow::UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard, UbuntuScreen *screen,
-                           UbuntuInput *input, MirConnection *connection)
+UbuntuWindow::UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
+                           UbuntuInput *input, UbuntuNativeInterface *native, MirConnection *connection)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
     , mClipboard(clipboard)
-    , mSurface(new UbuntuSurface{this, screen, input, connection})
+    , mNativeInterface(native)
+    , mWindowState(w->windowState())
+    , mWindowFlags(w->flags())
+    , mWindowVisible(false)
+    , mSurface(new UbuntuSurface{this, static_cast<UbuntuScreen*>(w->screen()->handle()), input, connection})
 {
-    qCDebug(ubuntumirclient, "UbuntuWindow(window=%p, screen=%p, input=%p, surf=%p)", w, screen, input, mSurface.get());
+    qCDebug(ubuntumirclient, "UbuntuWindow(window=%p, screen=%p, input=%p, surf=%p) with title '%s', role: '%d'",
+            w, w->screen()->handle(), input, mSurface.get(), qPrintable(window()->title()), roleFor(window()));
+
+    enablePanelHeightHack(w->windowState() != Qt::WindowFullScreen);
 }
 
 UbuntuWindow::~UbuntuWindow()
@@ -504,12 +533,25 @@
     qCDebug(ubuntumirclient, "~UbuntuWindow(window=%p)", this);
 }
 
-void UbuntuWindow::handleSurfaceResized(int width, int height)
+void UbuntuWindow::updateWindowSize(int widthPx, int heightPx) // after when Mir has resized the surface
+{
+    const float dpr = devicePixelRatio();
+    auto geom = geometry();
+    geom.setWidth(divideAndRoundUp(widthPx, dpr));
+    geom.setHeight(divideAndRoundUp(heightPx, dpr));
+
+    QPlatformWindow::setGeometry(geom);
+    QWindowSystemInterface::handleGeometryChange(window(), geom);
+
+    qCDebug(ubuntumirclient) << "Surface geometry updated:" << geom;
+}
+
+void UbuntuWindow::handleSurfaceResized(int widthPx, int heightPx)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p, width=%d, height=%d)", window(), width, height);
+    qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p, size=(%dx%d)px", window(), widthPx, heightPx);
 
-    mSurface->handleSurfaceResized(width, height);
+    mSurface->handleSurfaceResized(widthPx, heightPx);
 
     // This resize event could have occurred just after the last buffer swap for this window.
     // This means the client may still be holding a buffer with the older size. The first redraw call
@@ -517,13 +559,26 @@
     // updated size but it still needs re-rendering so another redraw may be needed.
     // A mir API to drop the currently held buffer would help here, so that we wouldn't have to redraw twice
     auto const numRepaints = mSurface->needsRepaint();
+    lock.unlock();
     qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) redraw %d times", window(), numRepaints);
     for (int i = 0; i < numRepaints; i++) {
-        qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) repainting width=%d, height=%d", window(), geometry().size().width(), geometry().size().height());
+        qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) repainting size=(%dx%d)dp", window(), geometry().size().width(), geometry().size().height());
         QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(), geometry().size()));
     }
 }
 
+void UbuntuWindow::handleSurfaceExposeChange(bool exposed)
+{
+    QMutexLocker lock(&mMutex);
+    qCDebug(ubuntumirclient, "handleSurfaceExposeChange(exposed=%s)", exposed ? "true" : "false");
+
+    mSurface->setVisible(exposed);
+    const QRect& exposeRect = exposed ? QRect(QPoint(), geometry().size()) : QRect();
+
+    lock.unlock();
+    QWindowSystemInterface::handleExposeEvent(window(), exposeRect);
+}
+
 void UbuntuWindow::handleSurfaceFocused()
 {
     qCDebug(ubuntumirclient, "handleSurfaceFocused(window=%p)", window());
@@ -537,13 +592,40 @@
     mClipboard->requestDBusClipboardContents();
 }
 
+void UbuntuWindow::handleSurfaceStateChanged(Qt::WindowState state)
+{
+    QMutexLocker lock(&mMutex);
+    qCDebug(ubuntumirclient, "handleSurfaceStateChanged(window=%p, %s)", window(), qtWindowStateToStr(state));
+
+    if (mWindowState == state) return;
+    mWindowState = state;
+
+    lock.unlock();
+    updateSurfaceState();
+    QWindowSystemInterface::handleWindowStateChanged(window(), state);
+}
+
 void UbuntuWindow::setWindowState(Qt::WindowState state)
 {
     QMutexLocker lock(&mMutex);
     qCDebug(ubuntumirclient, "setWindowState(window=%p, %s)", this, qtWindowStateToStr(state));
-    mSurface->setState(state);
-
-    updatePanelHeightHack(state);
+
+    if (mWindowState == state) return;
+    mWindowState = state;
+
+    lock.unlock();
+    updateSurfaceState();
+}
+
+void UbuntuWindow::setWindowFlags(Qt::WindowFlags flags)
+{
+    QMutexLocker lock(&mMutex);
+    qCDebug(ubuntumirclient, "setWindowFlags(window=%p, %d)", this, flags);
+
+    if (mWindowFlags == flags) return;
+    mWindowFlags = flags;
+
+    mSurface->setShellChrome(mWindowFlags & WindowHidesShellDecorations ? mir_shell_chrome_low : mir_shell_chrome_normal);
 }
 
 /*
@@ -552,34 +634,37 @@
     window is always on the top-left corner, right below the indicators panel if not
     in fullscreen.
  */
-void UbuntuWindow::updatePanelHeightHack(Qt::WindowState state)
+void UbuntuWindow::enablePanelHeightHack(bool enable)
 {
-    if (state == Qt::WindowFullScreen && geometry().y() != 0) {
-        QRect newGeometry = geometry();
+    QMutexLocker lock(&mMutex);
+
+    QRect newGeometry = geometry();
+    if (enable) {
+        newGeometry.setY(panelHeight());
+    } else {
         newGeometry.setY(0);
-        QPlatformWindow::setGeometry(newGeometry);
-        QWindowSystemInterface::handleGeometryChange(window(), newGeometry);
-    } else if (geometry().y() == 0) {
-        QRect newGeometry = geometry();
-        newGeometry.setY(panelHeight());
+    }
+
+    if (newGeometry != geometry()) {
+        lock.unlock();
         QPlatformWindow::setGeometry(newGeometry);
         QWindowSystemInterface::handleGeometryChange(window(), newGeometry);
     }
 }
 
-void UbuntuWindow::setGeometry(const QRect& rect)
+void UbuntuWindow::setGeometry(const QRect &rect)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "setGeometry (window=%p, x=%d, y=%d, width=%d, height=%d)",
-           window(), rect.x(), rect.y(), rect.width(), rect.height());
+    qCDebug(ubuntumirclient, "setGeometry (window=%p, position=(%d, %d)dp, size=(%dx%d)dp)",
+            window(), rect.x(), rect.y(), rect.width(), rect.height());
 
     //NOTE: mir surfaces cannot be moved by the client so ignore the topLeft coordinates
     const auto newSize = rect.size();
     auto newGeometry = geometry();
     newGeometry.setSize(newSize);
-    QPlatformWindow::setGeometry(newGeometry);
 
-    mSurface->resize(newSize);
+    mSurface->resize(newSize * devicePixelRatio());
+    // Note: don't call handleGeometryChange here, wait to see what Mir replies with.
 }
 
 void UbuntuWindow::setVisible(bool visible)
@@ -587,15 +672,17 @@
     QMutexLocker lock(&mMutex);
     qCDebug(ubuntumirclient, "setVisible (window=%p, visible=%s)", window(), visible ? "true" : "false");
 
-    mSurface->setVisible(visible);
-    const QRect& exposeRect = visible ? QRect(QPoint(), geometry().size()) : QRect();
+    if (mWindowVisible == visible) return;
+    mWindowVisible = visible;
+    if (mWindowVisible) mSurface->updateSurface();
 
     lock.unlock();
+    updateSurfaceState();
+    const QRect& exposeRect = mWindowVisible ? QRect(QPoint(), geometry().size()) : QRect();
     QWindowSystemInterface::handleExposeEvent(window(), exposeRect);
-    QWindowSystemInterface::flushWindowSystemEvents();
 }
 
-void UbuntuWindow::setWindowTitle(const QString& title)
+void UbuntuWindow::setWindowTitle(const QString &title)
 {
     QMutexLocker lock(&mMutex);
     qCDebug(ubuntumirclient, "setWindowTitle(window=%p) title=%s)", window(), title.toUtf8().constData());
@@ -606,11 +693,22 @@
 {
     QMutexLocker lock(&mMutex);
     const auto win = window();
-    qCDebug(ubuntumirclient, "propagateSizeHints(window=%p) min(%d,%d), max(%d,%d) increment(%d, %d)",
-           win, win->minimumSize().width(), win->minimumSize().height(),
-           win->maximumSize().width(), win->maximumSize().height(),
-           win->sizeIncrement().width(), win->sizeIncrement().height());
-    mSurface->setSizingConstraints(win->minimumSize(), win->maximumSize(), win->sizeIncrement());
+    const float dpr = devicePixelRatio();
+    qCDebug(ubuntumirclient, "propagateSizeHints(window=%p) min(%dx%d)dp; max(%dx%d)dp; increment(%dx%d)dp",
+            win, win->minimumSize().width(), win->minimumSize().height(),
+            win->maximumSize().width(), win->maximumSize().height(),
+            win->sizeIncrement().width(), win->sizeIncrement().height());
+    mSurface->setSizingConstraints(win->minimumSize() * dpr, win->maximumSize() * dpr, win->sizeIncrement() * dpr);
+}
+
+qreal UbuntuWindow::devicePixelRatio() const
+{
+    return screen() ? screen()->devicePixelRatio() : 1.0; // not impossible a Window has no attached Screen
+}
+
+bool UbuntuWindow::isExposed() const
+{
+    return mWindowVisible;
 }
 
 void* UbuntuWindow::eglSurface() const
@@ -633,3 +731,33 @@
     QMutexLocker lock(&mMutex);
     mSurface->onSwapBuffersDone();
 }
+
+void UbuntuWindow::handleScreenPropertiesChange(MirFormFactor formFactor, float scale)
+{
+    // Update the scale & form factor native-interface properties for the windows affected
+    // as there is no convenient way to emit signals for those custom properties on a QScreen
+    if (formFactor != mFormFactor) {
+        mFormFactor = formFactor;
+        Q_EMIT mNativeInterface->windowPropertyChanged(this, QStringLiteral("formFactor"));
+    }
+
+    if (!qFuzzyCompare(scale, mScale)) {
+        mScale = scale;
+        Q_EMIT mNativeInterface->windowPropertyChanged(this, QStringLiteral("scale"));
+    }
+}
+
+void UbuntuWindow::updateSurfaceState()
+{
+    QMutexLocker lock(&mMutex);
+    MirSurfaceState newState = mWindowVisible ? qtWindowStateToMirSurfaceState(mWindowState) :
+                                                mir_surface_state_minimized;
+    qCDebug(ubuntumirclient, "updateSurfaceState (window=%p, surfaceState=%s)", window(), mirSurfaceStateToStr(newState));
+    if (newState != mSurface->state()) {
+        mSurface->setState(newState);
+
+        lock.unlock();
+        enablePanelHeightHack(newState != mir_surface_state_fullscreen &&
+                              mSurface->type() != mir_surface_type_inputmethod);
+    }
+}

=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2015-12-16 17:55:47 +0000
+++ src/ubuntumirclient/window.h	2016-02-17 14:37:36 +0000
@@ -18,13 +18,15 @@
 #define UBUNTU_WINDOW_H
 
 #include <qpa/qplatformwindow.h>
-#include <QLoggingCategory>
 #include <QSharedPointer>
 #include <QMutex>
 
+#include <mir_toolkit/common.h> // needed only for MirFormFactor enum
+
 #include <memory>
 
 class UbuntuClipboard;
+class UbuntuNativeInterface;
 class UbuntuInput;
 class UbuntuScreen;
 class UbuntuSurface;
@@ -35,31 +37,49 @@
 {
     Q_OBJECT
 public:
-    UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard, UbuntuScreen *screen,
-                 UbuntuInput *input, MirConnection *mirConnection);
+    UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
+                 UbuntuInput *input, UbuntuNativeInterface* native, MirConnection *mirConnection);
     virtual ~UbuntuWindow();
 
     // QPlatformWindow methods.
     WId winId() const override;
     void setGeometry(const QRect&) override;
     void setWindowState(Qt::WindowState state) override;
+    void setWindowFlags(Qt::WindowFlags flags) override;
     void setVisible(bool visible) override;
     void setWindowTitle(const QString &title) override;
     void propagateSizeHints() override;
+    bool isExposed() const override;
+    qreal devicePixelRatio() const override;
+
+    // Additional Window properties exposed by NativeInterface
+    MirFormFactor formFactor() const { return mFormFactor; }
+    float scale() const { return mScale; }
 
     // New methods.
     void *eglSurface() const;
     MirSurface *mirSurface() const;
-    void handleSurfaceResized(int width, int height);
+    void updateWindowSize(int widthPx, int heightPx);
+    void handleSurfaceResized(int widthPx, int heightPx);
+    void handleSurfaceExposeChange(bool exposed);
     void handleSurfaceFocused();
+    void handleSurfaceStateChanged(Qt::WindowState state);
     void onSwapBuffersDone();
+    void handleScreenPropertiesChange(MirFormFactor formFactor, float scale);
 
 private:
-    void updatePanelHeightHack(Qt::WindowState);
+    void enablePanelHeightHack(bool enable);
+    void updateSurfaceState();
     mutable QMutex mMutex;
     const WId mId;
     const QSharedPointer<UbuntuClipboard> mClipboard;
+    Qt::WindowState mWindowState;
+    Qt::WindowFlags mWindowFlags;
+    bool mWindowVisible;
+    UbuntuNativeInterface *mNativeInterface;
     std::unique_ptr<UbuntuSurface> mSurface;
+    float mScale;
+    MirFormFactor mFormFactor;
 };
 
 #endif // UBUNTU_WINDOW_H