Merge lp:~gerboland/qtubuntu/add--more-surface-type-support into lp:qtubuntu

[Gerry Boland]

Add support for more surface types and surface repositioning.

Helps Menus, Dropdowns and Tooltips to work with Mir

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:297
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/145/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/145/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gerboland/qtubuntu/add--more-surface-type-support]

298. By Gerry Boland on 2016-10-13

Fix input method bug, missing break in switch

299. By Gerry Boland on 2016-10-13

Using mirclient version better for gating on mirclient api

300. By Gerry Boland on 2016-10-18

Fix for dialogs crash

301. By Gerry Boland on 2016-10-26

This is not python, fix comment

302. By Gerry Boland on 2016-11-03

Only set internal position in setGeometry, not size

303. By Gerry Boland on 2016-11-04

Merge trunk & resolve conflict

Unmerged revisions

=== modified file 'debian/control'
--- debian/control	2016-08-24 12:40:30 +0000
+++ debian/control	2016-10-13 10:20:24 +0000
@@ -11,6 +11,7 @@
                libglib2.0-dev,
                libinput-dev,
                libmirclient-dev (>= 0.13.0),
+               libmirclient-debug-extension-dev,
                libmtdev-dev,
                libubuntu-application-api-dev (>= 2.9.0),
                libudev-dev,

=== modified file 'src/ubuntumirclient/backingstore.cpp'
--- src/ubuntumirclient/backingstore.cpp	2016-04-20 16:10:06 +0000
+++ src/ubuntumirclient/backingstore.cpp	2016-10-13 10:20:24 +0000
@@ -35,9 +35,7 @@
     window->setSurfaceType(QSurface::OpenGLSurface);
 }
 
-UbuntuBackingStore::~UbuntuBackingStore()
-{
-}
+UbuntuBackingStore::~UbuntuBackingStore() = default;
 
 void UbuntuBackingStore::flush(QWindow* window, const QRegion& region, const QPoint& offset)
 {
@@ -125,3 +123,9 @@
 {
     return &mImage;
 }
+
+QImage UbuntuBackingStore::toImage() const
+{
+    // used by QPlatformBackingStore::composeAndFlush
+    return mImage;
+}

=== modified file 'src/ubuntumirclient/backingstore.h'
--- src/ubuntumirclient/backingstore.h	2014-11-11 14:34:12 +0000
+++ src/ubuntumirclient/backingstore.h	2016-10-13 10:20:24 +0000
@@ -34,6 +34,7 @@
     void flush(QWindow* window, const QRegion& region, const QPoint& offset) override;
     void resize(const QSize& size, const QRegion& staticContents) override;
     QPaintDevice* paintDevice() override;
+    QImage toImage() const override;
 
 protected:
     void updateTexture();

=== added file 'src/ubuntumirclient/debugextension.cpp'
--- src/ubuntumirclient/debugextension.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/debugextension.cpp	2016-10-13 10:20:24 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 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 "debugextension.h"
+
+#include "logging.h"
+
+// mir client debug
+#include <mir_toolkit/debug/surface.h>
+
+Q_LOGGING_CATEGORY(ubuntumirclientDebug, "ubuntumirclient.debug")
+
+UbuntuDebugExtension::UbuntuDebugExtension()
+    : m_mirclientDebug(QStringLiteral("mirclient-debug-extension"), 1)
+    , m_mapper(nullptr)
+{
+    qCDebug(ubuntumirclientDebug) << "NOTICE: Loading mirclient-debug-extension";
+    m_mapper = (MapperPrototype) m_mirclientDebug.resolve("mir_debug_surface_coords_to_screen");
+
+    if (!m_mirclientDebug.isLoaded()) {
+        qCWarning(ubuntumirclientDebug) << "ERROR: mirclient-debug-extension failed to load:"
+                                        << m_mirclientDebug.errorString();
+    } else if (!m_mapper) {
+        qCWarning(ubuntumirclientDebug) << "ERROR: unable to find required symbols in mirclient-debug-extension:"
+                                        << m_mirclientDebug.errorString();
+    }
+}
+
+QPoint UbuntuDebugExtension::mapSurfacePointToScreen(MirSurface *surface, const QPoint &point)
+{
+    if (!m_mapper) {
+        return point;
+    }
+
+    QPoint mappedPoint;
+    bool status = m_mapper(surface, point.x(), point.y(), &mappedPoint.rx(), &mappedPoint.ry());
+    if (status) {
+        return mappedPoint;
+    } else {
+        return point;
+    }
+}

=== added file 'src/ubuntumirclient/debugextension.h'
--- src/ubuntumirclient/debugextension.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/debugextension.h	2016-10-13 10:20:24 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 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_DEBUG_EXTENSION_H
+#define UBUNTU_DEBUG_EXTENSION_H
+
+#include <QPoint>
+#include <QLibrary>
+struct MirSurface;
+
+typedef bool (*MapperPrototype)(MirSurface* surface, int x, int y, int* screenX, int* screenY);
+
+
+class UbuntuDebugExtension
+{
+public:
+    UbuntuDebugExtension();
+
+    QPoint mapSurfacePointToScreen(MirSurface *, const QPoint &point);
+
+private:
+    QLibrary m_mirclientDebug;
+    MapperPrototype m_mapper;
+};
+
+#endif // UBUNTU_DEBUG_EXTENSION_H

=== added file 'src/ubuntumirclient/desktopwindow.cpp'
--- src/ubuntumirclient/desktopwindow.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/desktopwindow.cpp	2016-10-13 10:20:24 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2016 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 "desktopwindow.h"
+
+// local
+#include "logging.h"
+
+UbuntuDesktopWindow::UbuntuDesktopWindow(QWindow *window)
+    : QPlatformWindow(window)
+{
+    qCDebug(ubuntumirclient, "UbuntuDesktopWindow(window=%p)", window);
+}

=== added file 'src/ubuntumirclient/desktopwindow.h'
--- src/ubuntumirclient/desktopwindow.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/desktopwindow.h	2016-10-13 10:20:24 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 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_DESKTOP_WINDOW_H
+#define UBUNTU_DESKTOP_WINDOW_H
+
+#include <qpa/qplatformwindow.h>
+
+// TODO Implement it. For now it's just an empty, dummy class.
+class UbuntuDesktopWindow : public QPlatformWindow
+{
+public:
+    UbuntuDesktopWindow(QWindow*);
+};
+
+#endif // UBUNTU_DESKTOP_WINDOW_H

=== modified file 'src/ubuntumirclient/glcontext.cpp'
--- src/ubuntumirclient/glcontext.cpp	2016-08-17 15:32:38 +0000
+++ src/ubuntumirclient/glcontext.cpp	2016-10-13 10:20:24 +0000
@@ -74,8 +74,6 @@
 
 bool UbuntuOpenGLContext::makeCurrent(QPlatformSurface* surface)
 {
-    Q_ASSERT(surface->surface()->surfaceType() == QSurface::OpenGLSurface);
-
     const bool ret = QEGLPlatformContext::makeCurrent(surface);
 
     if (Q_LIKELY(ret)) {

=== modified file 'src/ubuntumirclient/input.cpp'
--- src/ubuntumirclient/input.cpp	2016-09-21 10:25:33 +0000
+++ src/ubuntumirclient/input.cpp	2016-10-13 10:20:24 +0000
@@ -501,6 +501,8 @@
     const auto localPoint = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_x),
                                     mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
 
+    mLastInputWindow = platformWindow;
+
     switch (action) {
     case mir_pointer_action_button_up:
     case mir_pointer_action_button_down:

=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2016-09-28 10:51:25 +0000
+++ src/ubuntumirclient/integration.cpp	2016-10-13 10:20:24 +0000
@@ -18,6 +18,8 @@
 #include "integration.h"
 #include "backingstore.h"
 #include "clipboard.h"
+#include "desktopwindow.h"
+#include "debugextension.h"
 #include "glcontext.h"
 #include "input.h"
 #include "logging.h"
@@ -29,6 +31,7 @@
 // Qt
 #include <QFileInfo>
 #include <QGuiApplication>
+#include <private/qeglpbuffer_p.h>
 #include <qpa/qplatformnativeinterface.h>
 #include <qpa/qplatforminputcontextfactory_p.h>
 #include <qpa/qplatforminputcontext.h>
@@ -70,7 +73,8 @@
     QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationSuspended);
 }
 
-UbuntuClientIntegration::UbuntuClientIntegration()
+
+UbuntuClientIntegration::UbuntuClientIntegration(int argc, char **argv)
     : QPlatformIntegration()
     , mNativeInterface(new UbuntuNativeInterface(this))
     , mFontDb(new QGenericUnixFontDatabase)
@@ -105,6 +109,17 @@
     mEglNativeDisplay = mir_connection_get_egl_native_display(mMirConnection);
     ASSERT((mEglDisplay = eglGetDisplay(mEglNativeDisplay)) != EGL_NO_DISPLAY);
     ASSERT(eglInitialize(mEglDisplay, nullptr, nullptr) == EGL_TRUE);
+
+    // Has debug mode been requsted, either with "-testability" switch or QT_LOAD_TESTABILITY env var
+    bool testability = qEnvironmentVariableIsSet("QT_LOAD_TESTABILITY");
+    for (int i=1; !testability && i<argc; i++) {
+        if (strcmp(argv[i], "-testability") == 0) {
+            testability = true;
+        }
+    }
+    if (testability) {
+        mDebugExtension.reset(new UbuntuDebugExtension);
+    }
 }
 
 void UbuntuClientIntegration::initialize()
@@ -211,21 +226,17 @@
 
 QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window) const
 {
-    return new UbuntuWindow(window, mInput, mNativeInterface, mEglDisplay, mMirConnection);
+    if (window->type() == Qt::Desktop) {
+        // Desktop windows should not be backed up by a mir surface as they don't draw anything (nor should).
+        return new UbuntuDesktopWindow(window);
+    } else {
+        return new UbuntuWindow(window, mInput, mNativeInterface, mEglDisplay, mMirConnection, mDebugExtension.data());
+    }
 }
 
 bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
 {
     switch (cap) {
-    case ThreadedPixmaps:
-        return true;
-
-    case OpenGL:
-        return true;
-
-    case ApplicationState:
-        return true;
-
     case ThreadedOpenGL:
         if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_THREADED_OPENGL")) {
             return true;
@@ -233,8 +244,16 @@
             qCDebug(ubuntumirclient, "disabled threaded OpenGL");
             return false;
         }
+
+    case ThreadedPixmaps:
+    case OpenGL:
+    case ApplicationState:
     case MultipleWindows:
     case NonFullScreenWindows:
+#if QT_VERSION > QT_VERSION_CHECK(5, 5, 0)
+    case SwitchableWidgetComposition:
+#endif
+    case RasterGLSurface: // needed for QQuickWidget
         return true;
     default:
         return QPlatformIntegration::hasCapability(cap);

=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2016-08-24 12:40:30 +0000
+++ src/ubuntumirclient/integration.h	2016-10-13 10:20:24 +0000
@@ -29,6 +29,7 @@
 
 #include <EGL/egl.h>
 
+class UbuntuDebugExtension;
 class UbuntuInput;
 class UbuntuNativeInterface;
 class UbuntuScreen;
@@ -39,7 +40,7 @@
     Q_OBJECT
 
 public:
-    UbuntuClientIntegration();
+    UbuntuClientIntegration(int argc, char **argv);
     virtual ~UbuntuClientIntegration();
 
     // QPlatformIntegration methods.
@@ -64,6 +65,7 @@
     EGLDisplay eglDisplay() const { return mEglDisplay; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
     UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
+    UbuntuDebugExtension *debugExtension() const { return mDebugExtension.data(); }
 
 private Q_SLOTS:
     void destroyScreen(UbuntuScreen *screen);
@@ -81,6 +83,7 @@
 
     UbuntuInput* mInput;
     QPlatformInputContext* mInputContext;
+    QScopedPointer<UbuntuDebugExtension> mDebugExtension;
     QScopedPointer<UbuntuScreenObserver> mScreenObserver;
     qreal mScaleFactor;
 

=== modified file 'src/ubuntumirclient/logging.h'
--- src/ubuntumirclient/logging.h	2016-06-22 17:16:33 +0000
+++ src/ubuntumirclient/logging.h	2016-10-13 10:20:24 +0000
@@ -26,5 +26,6 @@
 Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientInput)
 Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientGraphics)
 Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientCursor)
+Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientDebug)
 
 #endif  // QUBUNTULOGGING_H

=== modified file 'src/ubuntumirclient/plugin.cpp'
--- src/ubuntumirclient/plugin.cpp	2015-12-04 16:19:33 +0000
+++ src/ubuntumirclient/plugin.cpp	2016-10-13 10:20:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2016 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
@@ -20,15 +20,9 @@
 
 Q_LOGGING_CATEGORY(ubuntumirclient, "ubuntumirclient", QtWarningMsg)
 
-QStringList UbuntuMirClientIntegrationPlugin::keys() const
-{
-    QStringList list;
-    list << QStringLiteral("ubuntumirclient");
-    return list;
-}
-
-QPlatformIntegration* UbuntuMirClientIntegrationPlugin::create(const QString &system,
-                                                               const QStringList &)
+QPlatformIntegration *UbuntuMirClientIntegrationPlugin::create(const QString &system,
+                                                               const QStringList &/*paramList*/,
+                                                               int &argc, char **argv)
 {
     if (system.toLower() == QLatin1String("ubuntumirclient")) {
 #ifdef PLATFORM_API_TOUCH
@@ -36,7 +30,7 @@
 #else
         setenv("UBUNTU_PLATFORM_API_BACKEND", "desktop_mirclient", 1);
 #endif
-        return new UbuntuClientIntegration;
+        return new UbuntuClientIntegration(argc, argv);
     } else {
         return 0;
     }

=== modified file 'src/ubuntumirclient/plugin.h'
--- src/ubuntumirclient/plugin.h	2014-06-18 23:10:00 +0000
+++ src/ubuntumirclient/plugin.h	2016-10-13 10:20:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2016 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
@@ -25,8 +25,7 @@
     Q_PLUGIN_METADATA(IID QPlatformIntegrationFactoryInterface_iid FILE "ubuntumirclient.json")
 
 public:
-    QStringList keys() const;
-    QPlatformIntegration* create(const QString&, const QStringList&);
+    QPlatformIntegration *create(const QString &system, const QStringList &paramList, int &argc, char **argv) override;
 };
 
 #endif // UBUNTU_CLIENT_PLUGIN_H

=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2016-09-28 10:51:25 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2016-10-13 10:20:24 +0000
@@ -18,6 +18,8 @@
     backingstore.cpp \
     clipboard.cpp \
     cursor.cpp \
+    debugextension.cpp \
+    desktopwindow.cpp \
     glcontext.cpp \
     input.cpp \
     integration.cpp \
@@ -33,6 +35,8 @@
     backingstore.h \
     clipboard.h \
     cursor.h \
+    debugextension.h \
+    desktopwindow.h \
     glcontext.h \
     input.h \
     integration.h \

=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2016-09-28 10:33:40 +0000
+++ src/ubuntumirclient/window.cpp	2016-10-13 10:20:24 +0000
@@ -16,12 +16,15 @@
 
 // Local
 #include "window.h"
+#include "debugextension.h"
 #include "nativeinterface.h"
 #include "input.h"
+#include "integration.h"
 #include "screen.h"
 #include "logging.h"
 
 #include <mir_toolkit/mir_client_library.h>
+#include <mir_toolkit/version.h>
 
 // Qt
 #include <qpa/qwindowsysteminterface.h>
@@ -121,6 +124,23 @@
     }
 }
 
+const char *mirSurfaceTypeToStr(MirSurfaceType type)
+{
+    switch (type) {
+    case mir_surface_type_normal:       return "Normal";        /**< AKA "regular"                   */
+    case mir_surface_type_utility:      return "Utility";       /**< AKA "floating regular"          */
+    case mir_surface_type_dialog:       return "Dialog";
+    case mir_surface_type_gloss:        return "Gloss";
+    case mir_surface_type_freestyle:    return "Freestyle";
+    case mir_surface_type_menu:         return "Menu";
+    case mir_surface_type_inputmethod:  return "Input Method";  /**< AKA "OSK" or handwriting etc.   */
+    case mir_surface_type_satellite:    return "Satellite";     /**< AKA "toolbox"/"toolbar"         */
+    case mir_surface_type_tip:          return "Tip";           /**< AKA "tooltip"                   */
+    case mir_surface_types:             Q_UNREACHABLE();
+    }
+    return "";
+}
+
 MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
 {
     switch (state) {
@@ -138,6 +158,27 @@
     }
 }
 
+MirSurfaceType qtWindowTypeToMirSurfaceType(Qt::WindowType type)
+{
+    switch (type & Qt::WindowType_Mask) {
+    case Qt::Dialog:
+        return mir_surface_type_dialog;
+    case Qt::Sheet:
+    case Qt::Drawer:
+        return mir_surface_type_utility;
+    case Qt::Popup:
+    case Qt::Tool:
+        return mir_surface_type_menu;
+    case Qt::ToolTip:
+        return mir_surface_type_tip;
+    case Qt::SplashScreen:
+        return mir_surface_type_freestyle;
+    case Qt::Window:
+    default:
+        return mir_surface_type_normal;
+    }
+}
+
 WId makeId()
 {
     static int id = 1;
@@ -163,51 +204,91 @@
     return parent ? static_cast<UbuntuWindow *>(parent->handle()) : nullptr;
 }
 
-Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirPixelFormat pixelFormat, 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;
+bool requiresParent(const MirSurfaceType type)
+{
+    switch (type) {
+    case mir_surface_type_utility:
+    case mir_surface_type_gloss:
+    case mir_surface_type_menu:
+    case mir_surface_type_satellite:
+    case mir_surface_type_tip:
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool requiresParent(const Qt::WindowType type)
+{
+    return requiresParent(qtWindowTypeToMirSurfaceType(type));
+}
+
+bool isMovable(const Qt::WindowType type)
+{
+    auto mirType = qtWindowTypeToMirSurfaceType(type);
+    switch (mirType) {
+    case mir_surface_type_menu:
+    case mir_surface_type_tip:
+        return true;
+    default:
+        return false;
+    }
+}
+
+Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, UbuntuWindow *parentWindowHandle,
+                     MirConnection *connection)
+{
+    const auto geometry = window->geometry();
+    const int width = geometry.width() > 0 ? geometry.width() : 1;
+    const int height = geometry.height() > 0 ? geometry.height() : 1;
+    auto type = qtWindowTypeToMirSurfaceType(window->type());
 
     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)};
-    }
-
-    const Qt::WindowType type = window->type();
-    if (type == Qt::Popup) {
-        auto parent = transientParentFor(window);
-        if (parent == nullptr) {
-            //NOTE: We cannot have a parentless popup -
-            //try using the last surface to receive input as that will most likely be
-            //the one that caused this popup to be created
-            parent = input->lastInputWindow();
-        }
-        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);
-            return Spec{mir_connection_create_spec_for_menu(
-                    connection, width, height, pixelFormat, parent->mirSurface(),
-                    &location, mir_edge_attachment_any)};
-        } else {
-            qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - cannot create a menu without a parent!", window);
-        }
-    } else if (type == Qt::Dialog) {
-        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())};
-        } 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 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)};
+        type = mir_surface_type_inputmethod;
+    }
+
+    MirRectangle location{geometry.x(), geometry.y(), 0, 0};
+    MirSurface *parent = nullptr;
+    if (parentWindowHandle) {
+        parent = parentWindowHandle->mirSurface();
+        // Qt uses absolute positioning, but Mir positions surfaces relative to parent.
+        location.top  -= parentWindowHandle->geometry().top();
+        location.left -= parentWindowHandle->geometry().left();
+    }
+
+    Spec spec;
+
+    switch (type) {
+    case mir_surface_type_menu:
+        spec = Spec{mir_connection_create_spec_for_menu(connection, width, height, pixelFormat, parent,
+                    &location, mir_edge_attachment_any)};
+        break;
+    case mir_surface_type_dialog:
+        spec = Spec{mir_connection_create_spec_for_modal_dialog(connection, width, height, pixelFormat, parent)};
+        break;
+    case mir_surface_type_utility:
+        spec = Spec{mir_connection_create_spec_for_dialog(connection, width, height, pixelFormat)};
+        break;
+    case mir_surface_type_tip:
+#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 25, 0)
+        spec = Spec{mir_connection_create_spec_for_tooltip(connection, width, height, pixelFormat, parent,
+                    &location)};
+#else
+        spec = Spec{mir_connection_create_spec_for_tip(connection, width, height, pixelFormat, parent,
+                    &location, mir_edge_attachment_any)};
+#endif
+        break;
+    case mir_surface_type_inputmethod:
+        spec = Spec{mir_connection_create_spec_for_input_method(connection, width, height, pixelFormat)};
+    default:
+        spec = Spec{mir_connection_create_spec_for_normal_surface(connection, width, height, pixelFormat)};
+        break;
+    }
+
+    qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
+            window, mirSurfaceTypeToStr(type), window->type(), location.left, location.top, width, height);
+
+    return std::move(spec);
 }
 
 void setSizingConstraints(MirSurfaceSpec *spec, const QSize& minSize, const QSize& maxSize, const QSize& increment)
@@ -228,11 +309,11 @@
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuInput *input, MirPixelFormat pixelFormat,
-                             MirConnection *connection, mir_surface_event_callback inputCallback,
-                             void* inputContext)
+MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuWindow *parentWindowHandle,
+                             MirPixelFormat pixelFormat, MirConnection *connection,
+                             mir_surface_event_callback inputCallback, void *inputContext)
 {
-    auto spec = makeSurfaceSpec(window, input, pixelFormat, connection);
+    auto spec = makeSurfaceSpec(window, pixelFormat, parentWindowHandle, connection);
 
     // Install event handler as early as possible
     mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
@@ -255,6 +336,20 @@
     return surface;
 }
 
+UbuntuWindow *getParentIfNecessary(QWindow *window, UbuntuInput *input)
+{
+    UbuntuWindow *parentWindowHandle = nullptr;
+    if (requiresParent(window->type())) {
+        parentWindowHandle = transientParentFor(window);
+        if (parentWindowHandle == nullptr) {
+            // NOTE: Mir requires this surface have a parent. Try using the last surface to receive input as that will
+            // most likely be the one that caused this surface to be created
+            parentWindowHandle = input->lastInputWindow();
+        }
+    }
+    return parentWindowHandle;
+}
+
 MirPixelFormat disableAlphaBufferIfPossible(MirPixelFormat pixelFormat)
 {
     switch(pixelFormat) {
@@ -286,98 +381,18 @@
 
 } //namespace
 
+
+
 class UbuntuSurface
 {
 public:
-    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection)
-        : mWindow(platformWindow->window())
-        , mPlatformWindow(platformWindow)
-        , mInput(input)
-        , mConnection(connection)
-        , mEglDisplay(display)
-        , mNeedsRepaint(false)
-        , mParented(mWindow->transientParent() || mWindow->parent())
-        , mFormat(mWindow->requestedFormat())
-        , mShellChrome(mWindow->flags() & LowChromeWindowHint ? mir_shell_chrome_low : mir_shell_chrome_normal)
-    {
-        // Have Qt choose most suitable EGLConfig for the requested surface format, and update format to reflect it
-        EGLConfig config = q_configFromGLFormat(display, mFormat, true);
-        if (config == 0) {
-            // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
-            // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
-            // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
-            // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
-            // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
-            static const bool isMesa = QString(eglQueryString(display, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
-            if (isMesa) {
-                qCDebug(ubuntumirclientGraphics, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
-                mFormat.setMajorVersion(1);
-                mFormat.setMinorVersion(4);
-                config = q_configFromGLFormat(display, mFormat, true);
-            }
-        }
-        if (config == 0) {
-            qCritical() << "Qt failed to choose a suitable EGLConfig to suit the surface format" << mFormat;
-        }
-
-        mFormat = q_glFormatFromConfig(display, config, mFormat);
-
-        // Have Mir decide the pixel format most suited to the chosen EGLConfig. This is the only way
-        // Mir will know what EGLConfig has been chosen - it cannot deduce it from the buffers.
-        auto pixelFormat = mir_connection_get_egl_pixel_format(connection, display, config);
-        // But the chosen EGLConfig might have an alpha buffer enabled, even if not requested by the client.
-        // If that's the case, try to edit the chosen pixel format in order to disable the alpha buffer.
-        // This is an optimisation for the compositor, as it can avoid blending this surface.
-        if (mWindow->requestedFormat().alphaBufferSize() < 0) {
-            pixelFormat = disableAlphaBufferIfPossible(pixelFormat);
-        }
-
-        const auto outputId = static_cast<UbuntuScreen *>(mWindow->screen()->handle())->mirOutputId();
-
-        mMirSurface = createMirSurface(mWindow, outputId, input, pixelFormat, connection, surfaceEventCallback, this);
-        mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
-
-        mNeedsExposeCatchup = mir_surface_get_visibility(mMirSurface) == mir_surface_visibility_occluded;
-
-        // 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 (mWindow->windowState() == Qt::WindowFullScreen) {
-            geom.moveTop(0);
-        } else {
-            geom.moveTop(panelHeight());
-        }
-
-        // Assume that the buffer size matches the surface size at creation time
-        mBufferSize = geom.size();
-        platformWindow->QPlatformWindow::setGeometry(geom);
-        QWindowSystemInterface::handleGeometryChange(mWindow, geom);
-
-        qCDebug(ubuntumirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title()
-                                 << "role:" << roleFor(mWindow);
-        qCDebug(ubuntumirclientGraphics)
-                                 << "Requested format:" << mWindow->requestedFormat()
-                                 << "\nActual format:" << mFormat
-                                 << "with associated Mir pixel format:" << mirPixelFormatToStr(pixelFormat);
-    }
-
-    ~UbuntuSurface()
-    {
-        if (mEglSurface != EGL_NO_SURFACE)
-            eglDestroySurface(mEglDisplay, mEglSurface);
-        if (mMirSurface)
-            mir_surface_release_sync(mMirSurface);
-    }
+    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection);
+    ~UbuntuSurface();
 
     UbuntuSurface(const UbuntuSurface &) = delete;
     UbuntuSurface& operator=(const UbuntuSurface &) = delete;
 
-    void resize(const QSize& newSize);
+    void updateGeometry(const QRect &newGeometry);
     void updateTitle(const QString& title);
     void setSizingConstraints(const QSize& minSize, const QSize& maxSize, const QSize& increment);
 
@@ -413,6 +428,7 @@
     UbuntuWindow * const mPlatformWindow;
     UbuntuInput * const mInput;
     MirConnection * const mConnection;
+    UbuntuWindow * mParentWindowHandle{nullptr};
 
     MirSurface* mMirSurface;
     const EGLDisplay mEglDisplay;
@@ -422,6 +438,7 @@
     bool mParented;
     QSize mBufferSize;
     QSurfaceFormat mFormat;
+    MirPixelFormat mPixelFormat;
 
     QMutex mTargetSizeMutex;
     QSize mTargetSize;
@@ -429,23 +446,102 @@
     QString mPersistentIdStr;
 };
 
-void UbuntuSurface::resize(const QSize& size)
-{
-    qCDebug(ubuntumirclient,"resize(window=%p, width=%d, height=%d)", mWindow, size.width(), size.height());
-
-    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()) {
-        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());
+UbuntuSurface::UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection)
+    : mWindow(platformWindow->window())
+    , mPlatformWindow(platformWindow)
+    , mInput(input)
+    , mConnection(connection)
+    , mEglDisplay(display)
+    , mNeedsRepaint(false)
+    , mParented(mWindow->transientParent() || mWindow->parent())
+    , mFormat(mWindow->requestedFormat())
+    , mShellChrome(mWindow->flags() & LowChromeWindowHint ? mir_shell_chrome_low : mir_shell_chrome_normal)
+{
+    // Have Qt choose most suitable EGLConfig for the requested surface format, and update format to reflect it
+    EGLConfig config = q_configFromGLFormat(display, mFormat, true);
+    if (config == 0) {
+        // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
+        // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
+        // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
+        // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
+        // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
+        static const bool isMesa = QString(eglQueryString(display, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
+        if (isMesa) {
+            qCDebug(ubuntumirclientGraphics, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
+            mFormat.setMajorVersion(1);
+            mFormat.setMinorVersion(4);
+            config = q_configFromGLFormat(display, mFormat, true);
+        }
+    }
+    if (config == 0) {
+        qCritical() << "Qt failed to choose a suitable EGLConfig to suit the surface format" << mFormat;
+    }
+
+    mFormat = q_glFormatFromConfig(display, config, mFormat);
+
+    // Have Mir decide the pixel format most suited to the chosen EGLConfig. This is the only way
+    // Mir will know what EGLConfig has been chosen - it cannot deduce it from the buffers.
+    mPixelFormat = mir_connection_get_egl_pixel_format(connection, display, config);
+    // But the chosen EGLConfig might have an alpha buffer enabled, even if not requested by the client.
+    // If that's the case, try to edit the chosen pixel format in order to disable the alpha buffer.
+    // This is an optimisation for the compositor, as it can avoid blending this surface.
+    if (mWindow->requestedFormat().alphaBufferSize() < 0) {
+        mPixelFormat = disableAlphaBufferIfPossible(mPixelFormat);
+    }
+
+    const auto outputId = static_cast<UbuntuScreen *>(mWindow->screen()->handle())->mirOutputId();
+
+    mParentWindowHandle = getParentIfNecessary(mWindow, input);
+
+    mMirSurface = createMirSurface(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
+    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
+
+    mNeedsExposeCatchup = mir_surface_get_visibility(mMirSurface) == mir_surface_visibility_occluded;
+
+    // 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);
+
+    // Assume that the buffer size matches the surface size at creation time
+    mBufferSize = geom.size();
+    platformWindow->QPlatformWindow::setGeometry(geom);
+    QWindowSystemInterface::handleGeometryChange(mWindow, geom);
+
+    qCDebug(ubuntumirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title()
+                             << "role:" << roleFor(mWindow);
+    qCDebug(ubuntumirclientGraphics)
+                             << "Requested format:" << mWindow->requestedFormat()
+                             << "\nActual format:" << mFormat
+                             << "with associated Mir pixel format:" << mirPixelFormatToStr(mPixelFormat);
+}
+
+UbuntuSurface::~UbuntuSurface()
+{
+    if (mEglSurface != EGL_NO_SURFACE)
+        eglDestroySurface(mEglDisplay, mEglSurface);
+    if (mMirSurface) {
+        mir_surface_release_sync(mMirSurface);
+    }
+}
+
+void UbuntuSurface::updateGeometry(const QRect &newGeometry)
+{
+    qCDebug(ubuntumirclient,"updateGeometry(window=%p, width=%d, height=%d)", mWindow,
+            newGeometry.width(), newGeometry.height());
+
+    Spec spec;
+    if (isMovable(mWindow->type())) {
+        spec = Spec{makeSurfaceSpec(mWindow, mPixelFormat, mParentWindowHandle, mConnection)};
+    } else {
+        spec = Spec{mir_connection_create_spec_for_changes(mConnection)};
+        mir_surface_spec_set_width(spec.get(), newGeometry.width());
+        mir_surface_spec_set_height(spec.get(), newGeometry.height());
+    }
     mir_surface_apply_spec(mMirSurface, spec.get());
 }
 
@@ -600,13 +696,14 @@
 }
 
 UbuntuWindow::UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface *native,
-                           EGLDisplay eglDisplay, MirConnection *mirConnection)
+                           EGLDisplay eglDisplay, MirConnection *mirConnection, UbuntuDebugExtension *debugExt)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
     , mWindowState(w->windowState())
     , mWindowFlags(w->flags())
     , mWindowVisible(false)
+    , mDebugExtention(debugExt)
     , mNativeInterface(native)
     , mSurface(new UbuntuSurface{this, eglDisplay, input, mirConnection})
     , mScale(1.0)
@@ -688,7 +785,7 @@
 
 void UbuntuWindow::handleSurfaceVisibilityChanged(bool visible)
 {
-    qCDebug(ubuntumirclient, "handleSurfaceFocused(window=%p)", window());
+    qCDebug(ubuntumirclient, "handleSurfaceVisibilityChanged(window=%p, visible=%d)", window(), visible);
 
     if (mWindowVisible == visible) return;
     mWindowVisible = visible;
@@ -737,6 +834,10 @@
  */
 void UbuntuWindow::updatePanelHeightHack(bool enable)
 {
+    if ((window()->type() & Qt::WindowType_Mask) != Qt::Window) { // only plain windows get the hack
+        return;
+    }
+
     QMutexLocker lock(&mMutex);
 
     QRect newGeometry = geometry();
@@ -756,13 +857,17 @@
 void UbuntuWindow::setGeometry(const QRect &rect)
 {
     QMutexLocker lock(&mMutex);
+
+    if (window()->windowState() == Qt::WindowFullScreen || window()->windowState() == Qt::WindowMaximized) {
+        qCDebug(ubuntumirclient, "setGeometry(window=%p) - not resizing, window is maximized or fullscreen", window());
+        return;
+    }
+
     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();
-
-    mSurface->resize(newSize);
+    QPlatformWindow::setGeometry(rect); // Immediately update internal geometry so Qt believes position updated
+
+    mSurface->updateGeometry(rect);
     // Note: don't call handleGeometryChange here, wait to see what Mir replies with.
 }
 
@@ -819,6 +924,15 @@
     return mSurface->format();
 }
 
+QPoint UbuntuWindow::mapToGlobal(const QPoint &pos) const
+{
+    if (mDebugExtention) {
+        return mDebugExtention->mapSurfacePointToScreen(mSurface->mirSurface(), pos);
+    } else {
+        return pos;
+    }
+}
+
 void* UbuntuWindow::eglSurface() const
 {
     return mSurface->eglSurface();

=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2016-09-21 10:25:33 +0000
+++ src/ubuntumirclient/window.h	2016-10-13 10:20:24 +0000
@@ -27,6 +27,7 @@
 
 #include <EGL/egl.h>
 
+class UbuntuDebugExtension;
 class UbuntuNativeInterface;
 class UbuntuInput;
 class UbuntuScreen;
@@ -39,7 +40,7 @@
     Q_OBJECT
 public:
     UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay,
-                 MirConnection *mirConnection);
+                 MirConnection *mirConnection, UbuntuDebugExtension *debugExt);
     virtual ~UbuntuWindow();
 
     // QPlatformWindow methods.
@@ -52,6 +53,7 @@
     void propagateSizeHints() override;
     bool isExposed() const override;
 
+    QPoint mapToGlobal(const QPoint &pos) const override;
     QSurfaceFormat format() const override;
 
     // Additional Window properties exposed by NativeInterface
@@ -79,6 +81,7 @@
     Qt::WindowFlags mWindowFlags;
     bool mWindowVisible;
     bool mWindowExposed;
+    UbuntuDebugExtension *mDebugExtention;
     UbuntuNativeInterface *mNativeInterface;
     std::unique_ptr<UbuntuSurface> mSurface;
     float mScale;