Merge lp:~gerboland/qtubuntu/delete-qraster-crash into lp:qtubuntu

[Gerry Boland]

BackingStore: make current only if no existing context current

Paraphrasing QOpenGLCompositorBackingStore: "With render-to-texture-widgets QWidget makes sure the context is made current before destroying backingstores. That is however not the case for windows with regular widgets only."

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

PASSED: Continuous integration, rev:372
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/185/
Executed test runs:
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build/4144
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4172
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4010/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4010/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4010/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4010/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4010/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4010
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4010/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~gerboland/qtubuntu/delete-qraster-crash]

372. By Gerry Boland on 2017-02-21

BackingStore: make current only if no existing context current

Unmerged revisions

=== modified file 'README'
--- README	2016-09-29 15:12:29 +0000
+++ README	2017-02-21 12:29:19 +0000
@@ -44,13 +44,13 @@
   logged and debug messages are disabled. QtUbuntu provides the following
   logging categories:
 
-  * ubuntumirclient.cursor      - Messages about the cursor.
-  * ubuntumirclient.input       - Messages related to input and other Mir events.
-  * ubuntumirclient.graphics    - Messages related to graphics, GL and EGL.
-  * ubuntumirclient.swapBuffers - Messages related to surface buffer swapping.
-  * ubuntumirclient             - For all other messages form the ubuntumirclient QPA.
-  * ubuntuappmenu.registrar     - Messages related to application menu registration.
-  * ubuntuappmenu               - For all other messages form the ubuntuappmenu QPA theme.
+  * qt.qpa.mirclient.cursor      - Messages about the cursor.
+  * qt.qpa.mirclient.input       - Messages related to input and other Mir events.
+  * qt.qpa.mirclient.graphics    - Messages related to graphics, GL and EGL.
+  * qt.qpa.mirclient.swapBuffers - Messages related to surface buffer swapping.
+  * qt.qpa.mirclient             - For all other messages form the ubuntumirclient QPA.
+  * ubuntuappmenu.registrar      - Messages related to application menu registration.
+  * ubuntuappmenu                - For all other messages form the ubuntuappmenu QPA theme.
 
   The QT_QPA_EGLFS_DEBUG environment variable prints a little more information
   from Qt's internals.

=== modified file 'debian/changelog'
--- debian/changelog	2017-01-19 22:55:05 +0000
+++ debian/changelog	2017-02-21 12:29:19 +0000
@@ -1,3 +1,20 @@
+qtubuntu (0.63+17.04.20170215-0ubuntu1) zesty; urgency=medium
+
+  [ Albert Astals Cid ]
+  * Fix crash when starting konsole
+
+  [ Alberto Aguirre ]
+  * Changes for mir 0.26.1: PersitentID has been renamed to WindowID
+
+  [ Arthur Mello ]
+  * Update code to use new Mir Api's.
+
+  [ Gerry Boland, Nick Dedekind ]
+  * Class renaming and syntax changes to shrink delta with upstream
+    mirclient QPA plugin (which is equivalent to rev 360)
+
+ -- Michał Sawicz <[e-mail]>  Wed, 15 Feb 2017 08:23:33 +0000
+
 qtubuntu (0.63+17.04.20170119.2-0ubuntu1) zesty; urgency=medium
 
   [ Daniel d'Andrada ]

=== modified file 'src/ubuntuappmenu/gmenumodelplatformmenu.cpp'
--- src/ubuntuappmenu/gmenumodelplatformmenu.cpp	2016-12-09 17:04:05 +0000
+++ src/ubuntuappmenu/gmenumodelplatformmenu.cpp	2017-02-21 12:29:19 +0000
@@ -499,6 +499,11 @@
     if (m_menu != menu) {
         m_menu = menu;
         Q_EMIT propertyChanged();
+
+        if (menu) {
+            connect(menu, &QObject::destroyed,
+                    this, [this] { setMenu(nullptr); });
+        }
     }
 }
 

=== renamed file 'src/ubuntumirclient/appstatecontroller.cpp' => 'src/ubuntumirclient/qmirclientappstatecontroller.cpp'
--- src/ubuntumirclient/appstatecontroller.cpp	2016-10-12 15:07:35 +0000
+++ src/ubuntumirclient/qmirclientappstatecontroller.cpp	2017-02-21 12:29:19 +0000
@@ -1,31 +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 "appstatecontroller.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientappstatecontroller.h"
 
 #include <qpa/qwindowsysteminterface.h>
 
 /*
- * UbuntuAppStateController - updates Qt's QApplication::applicationState property.
+ * QMirClientAppStateController - updates Qt's QApplication::applicationState property.
  *
  * Tries to avoid active-inactive-active invocations using a timer. The rapid state
  * change can confuse some applications.
  */
 
-UbuntuAppStateController::UbuntuAppStateController()
+QMirClientAppStateController::QMirClientAppStateController()
     : m_suspended(false)
     , m_lastActive(true)
 {
@@ -37,7 +61,7 @@
     });
 }
 
-void UbuntuAppStateController::setSuspended()
+void QMirClientAppStateController::setSuspended()
 {
     m_inactiveTimer.stop();
     if (!m_suspended) {
@@ -47,7 +71,7 @@
     }
 }
 
-void UbuntuAppStateController::setResumed()
+void QMirClientAppStateController::setResumed()
 {
     m_inactiveTimer.stop();
     if (m_suspended) {
@@ -61,7 +85,7 @@
     }
 }
 
-void UbuntuAppStateController::setWindowFocused(bool focused)
+void QMirClientAppStateController::setWindowFocused(bool focused)
 {
     if (m_suspended) {
         return;

=== renamed file 'src/ubuntumirclient/appstatecontroller.h' => 'src/ubuntumirclient/qmirclientappstatecontroller.h'
--- src/ubuntumirclient/appstatecontroller.h	2016-10-12 15:05:58 +0000
+++ src/ubuntumirclient/qmirclientappstatecontroller.h	2017-02-21 12:29:19 +0000
@@ -1,28 +1,52 @@
-/*
- * 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 UBUNTUAPPSTATECONTROLLER_H
-#define UBUNTUAPPSTATECONTROLLER_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTAPPSTATECONTROLLER_H
+#define QMIRCLIENTAPPSTATECONTROLLER_H
 
 #include <QTimer>
 
-class UbuntuAppStateController
+class QMirClientAppStateController
 {
 public:
-    UbuntuAppStateController();
+    QMirClientAppStateController();
 
     void setSuspended();
     void setResumed();
@@ -35,4 +59,4 @@
     QTimer m_inactiveTimer;
 };
 
-#endif // UBUNTUAPPSTATECONTROLLER_H
+#endif // QMIRCLIENTAPPSTATECONTROLLER_H

=== renamed file 'src/ubuntumirclient/backingstore.cpp' => 'src/ubuntumirclient/qmirclientbackingstore.cpp'
--- src/ubuntumirclient/backingstore.cpp	2016-10-12 16:31:54 +0000
+++ src/ubuntumirclient/qmirclientbackingstore.cpp	2017-02-21 12:29:19 +0000
@@ -1,28 +1,52 @@
-/*
- * Copyright (C) 2014 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 "backingstore.h"
-#include "logging.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientbackingstore.h"
+#include "qmirclientlogging.h"
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QOpenGLTexture>
 #include <QtGui/QMatrix4x4>
 #include <QtGui/private/qopengltextureblitter_p.h>
 #include <QtGui/qopenglfunctions.h>
 
-UbuntuBackingStore::UbuntuBackingStore(QWindow* window)
+QMirClientBackingStore::QMirClientBackingStore(QWindow* window)
     : QPlatformBackingStore(window)
     , mContext(new QOpenGLContext)
     , mTexture(new QOpenGLTexture(QOpenGLTexture::Target2D))
@@ -35,12 +59,17 @@
     window->setSurfaceType(QSurface::OpenGLSurface);
 }
 
-UbuntuBackingStore::~UbuntuBackingStore()
+QMirClientBackingStore::~QMirClientBackingStore()
 {
-    mContext->makeCurrent(window()); // needed as QOpenGLTexture destructor assumes current context
+    // With render-to-texture-widgets QWidget makes sure the TLW's shareContext() is
+    // made current before destroying backingstores. That is however not the case for
+    // windows with regular widgets only.
+    if (!QOpenGLContext::currentContext()) {
+        mContext->makeCurrent(window());
+    }
 }
 
-void UbuntuBackingStore::flush(QWindow* window, const QRegion& region, const QPoint& offset)
+void QMirClientBackingStore::flush(QWindow* window, const QRegion& region, const QPoint& offset)
 {
     Q_UNUSED(region);
     Q_UNUSED(offset);
@@ -59,7 +88,7 @@
     mContext->swapBuffers(window);
 }
 
-void UbuntuBackingStore::updateTexture()
+void QMirClientBackingStore::updateTexture()
 {
     if (mDirty.isNull())
         return;
@@ -76,9 +105,7 @@
     QRegion fixed;
     QRect imageRect = mImage.rect();
 
-    /* Following code taken from QEGLPlatformBackingStore 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()) {
+    for (const QRect &rect : mDirty.rects()) {
         // intersect with image rect to be sure
         QRect r = imageRect & rect;
 
@@ -91,7 +118,7 @@
         fixed |= r;
     }
 
-    Q_FOREACH (const QRect &rect, fixed.rects()) {
+    for (const QRect &rect : fixed.rects()) {
         // if the sub-rect is full-width we can pass the image data directly to
         // OpenGL instead of copying, since there is no gap between scanlines
         if (rect.width() == imageRect.width()) {
@@ -108,12 +135,12 @@
 }
 
 
-void UbuntuBackingStore::beginPaint(const QRegion& region)
+void QMirClientBackingStore::beginPaint(const QRegion& region)
 {
     mDirty |= region;
 }
 
-void UbuntuBackingStore::resize(const QSize& size, const QRegion& /*staticContents*/)
+void QMirClientBackingStore::resize(const QSize& size, const QRegion& /*staticContents*/)
 {
     mImage = QImage(size, QImage::Format_RGBA8888);
 
@@ -123,12 +150,12 @@
         mTexture->destroy();
 }
 
-QPaintDevice* UbuntuBackingStore::paintDevice()
+QPaintDevice* QMirClientBackingStore::paintDevice()
 {
     return &mImage;
 }
 
-QImage UbuntuBackingStore::toImage() const
+QImage QMirClientBackingStore::toImage() const
 {
     // used by QPlatformBackingStore::composeAndFlush
     return mImage;

=== renamed file 'src/ubuntumirclient/backingstore.h' => 'src/ubuntumirclient/qmirclientbackingstore.h'
--- src/ubuntumirclient/backingstore.h	2016-10-04 16:20:07 +0000
+++ src/ubuntumirclient/qmirclientbackingstore.h	2017-02-21 12:29:19 +0000
@@ -1,21 +1,45 @@
-/*
- * Copyright (C) 2014 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_BACKING_STORE_H
-#define UBUNTU_BACKING_STORE_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTBACKINGSTORE_H
+#define QMIRCLIENTBACKINGSTORE_H
 
 #include <qpa/qplatformbackingstore.h>
 
@@ -23,11 +47,11 @@
 class QOpenGLTexture;
 class QOpenGLTextureBlitter;
 
-class UbuntuBackingStore : public QPlatformBackingStore
+class QMirClientBackingStore : public QPlatformBackingStore
 {
 public:
-    UbuntuBackingStore(QWindow* window);
-    virtual ~UbuntuBackingStore();
+    QMirClientBackingStore(QWindow* window);
+    virtual ~QMirClientBackingStore();
 
     // QPlatformBackingStore methods.
     void beginPaint(const QRegion&) override;
@@ -47,4 +71,4 @@
     QRegion mDirty;
 };
 
-#endif // UBUNTU_BACKING_STORE_H
+#endif // QMIRCLIENTBACKINGSTORE_H

=== renamed file 'src/ubuntumirclient/clipboard.cpp' => 'src/ubuntumirclient/qmirclientclipboard.cpp'
--- src/ubuntumirclient/clipboard.cpp	2016-08-24 12:40:30 +0000
+++ src/ubuntumirclient/qmirclientclipboard.cpp	2017-02-21 12:29:19 +0000
@@ -1,22 +1,46 @@
-/*
- * 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
- * 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 "clipboard.h"
-#include "logging.h"
-#include "window.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientclipboard.h"
+#include "qmirclientlogging.h"
+#include "qmirclientwindow.h"
 
 #include <QDBusPendingCallWatcher>
 #include <QGuiApplication>
@@ -30,29 +54,29 @@
 // get this cumbersome nested namespace out of the way
 using namespace com::ubuntu::content;
 
-UbuntuClipboard::UbuntuClipboard()
+QMirClientClipboard::QMirClientClipboard()
     : mMimeData(new QMimeData)
     , mContentHub(Hub::Client::instance())
 {
     connect(mContentHub, &Hub::pasteboardChanged, this, [this]() {
-        if (mClipboardState == UbuntuClipboard::SyncedClipboard) {
-            mClipboardState = UbuntuClipboard::OutdatedClipboard;
+        if (mClipboardState == QMirClientClipboard::SyncedClipboard) {
+            mClipboardState = QMirClientClipboard::OutdatedClipboard;
             emitChanged(QClipboard::Clipboard);
         }
     });
 
     connect(qGuiApp, &QGuiApplication::applicationStateChanged,
-        this, &UbuntuClipboard::onApplicationStateChanged);
+        this, &QMirClientClipboard::onApplicationStateChanged);
 
     requestMimeData();
 }
 
-UbuntuClipboard::~UbuntuClipboard()
+QMirClientClipboard::~QMirClientClipboard()
 {
     delete mMimeData;
 }
 
-QMimeData* UbuntuClipboard::mimeData(QClipboard::Mode mode)
+QMimeData* QMirClientClipboard::mimeData(QClipboard::Mode mode)
 {
     if (mode != QClipboard::Clipboard)
         return nullptr;
@@ -70,11 +94,11 @@
     return mMimeData;
 }
 
-void UbuntuClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
+void QMirClientClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
 {
     QWindow *focusWindow = QGuiApplication::focusWindow();
     if (focusWindow && mode == QClipboard::Clipboard && mimeData != nullptr) {
-        QString surfaceId = static_cast<UbuntuWindow*>(focusWindow->handle())->persistentSurfaceId();
+        QString surfaceId = static_cast<QMirClientWindow*>(focusWindow->handle())->persistentSurfaceId();
 
         QDBusPendingCall reply = mContentHub->createPaste(surfaceId, *mimeData);
 
@@ -89,18 +113,18 @@
     }
 }
 
-bool UbuntuClipboard::supportsMode(QClipboard::Mode mode) const
+bool QMirClientClipboard::supportsMode(QClipboard::Mode mode) const
 {
     return mode == QClipboard::Clipboard;
 }
 
-bool UbuntuClipboard::ownsMode(QClipboard::Mode mode) const
+bool QMirClientClipboard::ownsMode(QClipboard::Mode mode) const
 {
     Q_UNUSED(mode);
     return false;
 }
 
-void UbuntuClipboard::onApplicationStateChanged(Qt::ApplicationState state)
+void QMirClientClipboard::onApplicationStateChanged(Qt::ApplicationState state)
 {
     if (state == Qt::ApplicationActive) {
         // Only focused or active applications might be allowed to paste, so we probably
@@ -110,7 +134,7 @@
     }
 }
 
-void UbuntuClipboard::updateMimeData()
+void QMirClientClipboard::updateMimeData()
 {
     if (qGuiApp->applicationState() != Qt::ApplicationActive) {
         // Don't even bother asking as content-hub would probably ignore our request (and should).
@@ -121,14 +145,14 @@
 
     QWindow *focusWindow = QGuiApplication::focusWindow();
     if (focusWindow) {
-        QString surfaceId = static_cast<UbuntuWindow*>(focusWindow->handle())->persistentSurfaceId();
+        QString surfaceId = static_cast<QMirClientWindow*>(focusWindow->handle())->persistentSurfaceId();
         mMimeData = mContentHub->latestPaste(surfaceId);
         mClipboardState = SyncedClipboard;
         emitChanged(QClipboard::Clipboard);
     }
 }
 
-void UbuntuClipboard::requestMimeData()
+void QMirClientClipboard::requestMimeData()
 {
     if (qGuiApp->applicationState() != Qt::ApplicationActive) {
         // Don't even bother asking as content-hub would probably ignore our request (and should).
@@ -140,7 +164,7 @@
         return;
     }
 
-    QString surfaceId = static_cast<UbuntuWindow*>(focusWindow->handle())->persistentSurfaceId();
+    QString surfaceId = static_cast<QMirClientWindow*>(focusWindow->handle())->persistentSurfaceId();
     QDBusPendingCall reply = mContentHub->requestLatestPaste(surfaceId);
     mClipboardState = SyncingClipboard;
 

=== renamed file 'src/ubuntumirclient/clipboard.h' => 'src/ubuntumirclient/qmirclientclipboard.h'
--- src/ubuntumirclient/clipboard.h	2016-08-24 12:40:30 +0000
+++ src/ubuntumirclient/qmirclientclipboard.h	2017-02-21 12:29:19 +0000
@@ -1,21 +1,45 @@
-/*
- * 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
- * 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_CLIPBOARD_H
-#define UBUNTU_CLIPBOARD_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTCLIPBOARD_H
+#define QMIRCLIENTCLIPBOARD_H
 
 #include <qpa/qplatformclipboard.h>
 
@@ -32,12 +56,12 @@
 
 class QDBusPendingCallWatcher;
 
-class UbuntuClipboard : public QObject, public QPlatformClipboard
+class QMirClientClipboard : public QObject, public QPlatformClipboard
 {
     Q_OBJECT
 public:
-    UbuntuClipboard();
-    virtual ~UbuntuClipboard();
+    QMirClientClipboard();
+    virtual ~QMirClientClipboard();
 
     // QPlatformClipboard methods.
     QMimeData* mimeData(QClipboard::Mode mode = QClipboard::Clipboard) override;
@@ -65,4 +89,4 @@
     QDBusPendingCallWatcher *mPasteReply{nullptr};
 };
 
-#endif // UBUNTU_CLIPBOARD_H
+#endif // QMIRCLIENTCLIPBOARD_H

=== renamed file 'src/ubuntumirclient/cursor.cpp' => 'src/ubuntumirclient/qmirclientcursor.cpp'
--- src/ubuntumirclient/cursor.cpp	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientcursor.cpp	2017-02-21 12:29:19 +0000
@@ -1,29 +1,53 @@
-/*
- * 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 "cursor.h"
-
-#include "logging.h"
-#include "window.h"
+/****************************************************************************
+**
+** Copyright (C) 2015-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientcursor.h"
+
+#include "qmirclientlogging.h"
+#include "qmirclientwindow.h"
 
 #include <mir_toolkit/mir_client_library.h>
 
-Q_LOGGING_CATEGORY(ubuntumirclientCursor, "ubuntumirclient.cursor", QtWarningMsg)
+Q_LOGGING_CATEGORY(mirclientCursor, "qt.qpa.mirclient.cursor", QtWarningMsg)
 
-UbuntuCursor::UbuntuCursor(MirConnection *connection)
+QMirClientCursor::QMirClientCursor(MirConnection *connection)
     : mConnection(connection)
 {
     /*
@@ -58,7 +82,7 @@
 namespace {
 const char *qtCursorShapeToStr(Qt::CursorShape shape)
 {
-    switch(shape) {
+    switch (shape) {
     case Qt::ArrowCursor:
         return "Arrow";
     case Qt::UpArrowCursor:
@@ -111,39 +135,42 @@
 }
 } // anonymous namespace
 
-void UbuntuCursor::changeCursor(QCursor *windowCursor, QWindow *window)
+void QMirClientCursor::changeCursor(QCursor *windowCursor, QWindow *window)
 {
     if (!window) {
         return;
     }
 
-    MirSurface *surface = static_cast<UbuntuWindow*>(window->handle())->mirSurface();
+    MirWindow *mirWindow = static_cast<QMirClientWindow*>(window->handle())->mirWindow();
 
-    if (!surface) {
+    if (!mirWindow) {
         return;
     }
 
 
     if (windowCursor) {
-        qCDebug(ubuntumirclientCursor, "changeCursor shape=%s, window=%p", qtCursorShapeToStr(windowCursor->shape()), window);
+        qCDebug(mirclientCursor, "changeCursor shape=%s, window=%p", qtCursorShapeToStr(windowCursor->shape()), window);
         if (!windowCursor->pixmap().isNull()) {
-            configureMirCursorWithPixmapQCursor(surface, *windowCursor);
+            configureMirCursorWithPixmapQCursor(mirWindow, *windowCursor);
         } else if (windowCursor->shape() == Qt::BitmapCursor) {
             // TODO: Implement bitmap cursor support
-            applyDefaultCursorConfiguration(surface);
+            applyDefaultCursorConfiguration(mirWindow);
         } else {
             const auto &cursorName = mShapeToCursorName.value(windowCursor->shape(), QByteArray("left_ptr"));
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
             auto cursorConfiguration = mir_cursor_configuration_from_name(cursorName.data());
-            mir_surface_configure_cursor(surface, cursorConfiguration);
+#pragma GCC diagnostic pop
+            mir_window_configure_cursor(mirWindow, cursorConfiguration);
             mir_cursor_configuration_destroy(cursorConfiguration);
         }
     } else {
-        applyDefaultCursorConfiguration(surface);
+        applyDefaultCursorConfiguration(mirWindow);
     }
 
 }
 
-void UbuntuCursor::configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor)
+void QMirClientCursor::configureMirCursorWithPixmapQCursor(MirWindow *window, QCursor &cursor)
 {
     QImage image = cursor.pixmap().toImage();
 
@@ -170,16 +197,19 @@
 
     {
         auto configuration = mir_cursor_configuration_from_buffer_stream(bufferStream, cursor.hotSpot().x(), cursor.hotSpot().y());
-        mir_surface_configure_cursor(surface, configuration);
+        mir_window_configure_cursor(window, configuration);
         mir_cursor_configuration_destroy(configuration);
     }
 
     mir_buffer_stream_release_sync(bufferStream);
 }
 
-void UbuntuCursor::applyDefaultCursorConfiguration(MirSurface *surface)
+void QMirClientCursor::applyDefaultCursorConfiguration(MirWindow *window)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     auto cursorConfiguration = mir_cursor_configuration_from_name("left_ptr");
-    mir_surface_configure_cursor(surface, cursorConfiguration);
+#pragma GCC diagnostic pop
+    mir_window_configure_cursor(window, cursorConfiguration);
     mir_cursor_configuration_destroy(cursorConfiguration);
 }

=== renamed file 'src/ubuntumirclient/cursor.h' => 'src/ubuntumirclient/qmirclientcursor.h'
--- src/ubuntumirclient/cursor.h	2015-11-11 18:58:44 +0000
+++ src/ubuntumirclient/qmirclientcursor.h	2017-02-21 12:29:19 +0000
@@ -1,40 +1,65 @@
-/*
- * 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_CURSOR_H
-#define UBUNTU_CURSOR_H
+/****************************************************************************
+**
+** Copyright (C) 2015-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTCURSOR_H
+#define QMIRCLIENTCURSOR_H
 
 #include <qpa/qplatformcursor.h>
 
 #include <QMap>
 #include <QByteArray>
 
+#include <mir_toolkit/mir_window.h>
+
 struct MirConnection;
-struct MirSurface;
 
-class UbuntuCursor : public QPlatformCursor
+class QMirClientCursor : public QPlatformCursor
 {
 public:
-    UbuntuCursor(MirConnection *connection);
+    QMirClientCursor(MirConnection *connection);
     void changeCursor(QCursor *windowCursor, QWindow *window) override;
 private:
-    void configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor);
-    void applyDefaultCursorConfiguration(MirSurface *surface);
+    void configureMirCursorWithPixmapQCursor(MirWindow *window, QCursor &cursor);
+    void applyDefaultCursorConfiguration(MirWindow *window);
     QMap<int, QByteArray> mShapeToCursorName;
     MirConnection *mConnection;
 };
 
-#endif // UBUNTU_CURSOR_H
+#endif // QMIRCLIENTCURSOR_H

=== renamed file 'src/ubuntumirclient/debugextension.cpp' => 'src/ubuntumirclient/qmirclientdebugextension.cpp'
--- src/ubuntumirclient/debugextension.cpp	2016-12-01 22:28:20 +0000
+++ src/ubuntumirclient/qmirclientdebugextension.cpp	2017-02-21 12:29:19 +0000
@@ -1,57 +1,81 @@
-/*
- * 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"
+/****************************************************************************
+**
+** Copyright (C) 2016-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientdebugextension.h"
+
+#include "qmirclientlogging.h"
 
 // mir client debug
 #include <mir_toolkit/debug/surface.h>
 
-Q_LOGGING_CATEGORY(ubuntumirclientDebug, "ubuntumirclient.debug")
+Q_LOGGING_CATEGORY(mirclientDebug, "qt.qpa.mirclient.debug")
 
-UbuntuDebugExtension::UbuntuDebugExtension()
+QMirClientDebugExtension::QMirClientDebugExtension()
     : 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");
+    qCDebug(mirclientDebug) << "NOTICE: Loading mirclient-debug-extension";
+    m_mapper = (MapperPrototype) m_mirclientDebug.resolve("mir_extension_window_coordinate_translation");
 
     if (!m_mirclientDebug.isLoaded()) {
-        qCWarning(ubuntumirclientDebug) << "ERROR: mirclient-debug-extension failed to load:"
-                                        << m_mirclientDebug.errorString();
+        qCWarning(mirclientDebug) << "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();
+        qCWarning(mirclientDebug) << "ERROR: unable to find required symbols in mirclient-debug-extension:"
+                                  << m_mirclientDebug.errorString();
     }
 }
 
-bool UbuntuDebugExtension::isEnabled() const
+bool QMirClientDebugExtension::isEnabled() const
 {
     return m_mirclientDebug.isLoaded() && m_mapper;
 }
 
-QPoint UbuntuDebugExtension::mapSurfacePointToScreen(MirSurface *surface, const QPoint &point)
+QPoint QMirClientDebugExtension::mapWindowPointToScreen(MirWindow *window, const QPoint &point)
 {
     if (!m_mapper) {
         return point;
     }
 
     QPoint mappedPoint;
-    bool status = m_mapper(surface, point.x(), point.y(), &mappedPoint.rx(), &mappedPoint.ry());
+    bool status = m_mapper(window, point.x(), point.y(), &mappedPoint.rx(), &mappedPoint.ry());
     if (status) {
         return mappedPoint;
     } else {

=== renamed file 'src/ubuntumirclient/debugextension.h' => 'src/ubuntumirclient/qmirclientdebugextension.h'
--- src/ubuntumirclient/debugextension.h	2016-12-01 22:28:20 +0000
+++ src/ubuntumirclient/qmirclientdebugextension.h	2017-02-21 12:29:19 +0000
@@ -1,41 +1,66 @@
-/*
- * 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
+/****************************************************************************
+**
+** Copyright (C) 2016-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTDEBUGEXTENSION_H
+#define QMIRCLIENTDEBUGEXTENSION_H
 
 #include <QPoint>
 #include <QLibrary>
-struct MirSurface;
-
-typedef bool (*MapperPrototype)(MirSurface* surface, int x, int y, int* screenX, int* screenY);
-
-
-class UbuntuDebugExtension
+
+#include <mir_toolkit/mir_window.h>
+
+typedef bool (*MapperPrototype)(MirWindow* window, int x, int y, int* screenX, int* screenY);
+
+
+class QMirClientDebugExtension
 {
 public:
-    UbuntuDebugExtension();
+    QMirClientDebugExtension();
 
     bool isEnabled() const;
 
-    QPoint mapSurfacePointToScreen(MirSurface *, const QPoint &point);
+    QPoint mapWindowPointToScreen(MirWindow *, const QPoint &point);
 
 private:
     QLibrary m_mirclientDebug;
     MapperPrototype m_mapper;
 };
 
-#endif // UBUNTU_DEBUG_EXTENSION_H
+#endif // QMIRCLIENTDEBUGEXTENSION_H

=== renamed file 'src/ubuntumirclient/desktopwindow.cpp' => 'src/ubuntumirclient/qmirclientdesktopwindow.cpp'
--- src/ubuntumirclient/desktopwindow.cpp	2016-10-04 16:20:07 +0000
+++ src/ubuntumirclient/qmirclientdesktopwindow.cpp	2017-02-21 12:29:19 +0000
@@ -1,26 +1,50 @@
-/*
- * 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"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientdesktopwindow.h"
 
 // local
-#include "logging.h"
+#include "qmirclientlogging.h"
 
-UbuntuDesktopWindow::UbuntuDesktopWindow(QWindow *window)
+QMirClientDesktopWindow::QMirClientDesktopWindow(QWindow *window)
     : QPlatformWindow(window)
 {
-    qCDebug(ubuntumirclient, "UbuntuDesktopWindow(window=%p)", window);
+    qCDebug(mirclient, "QMirClientDesktopWindow(window=%p)", window);
 }

=== renamed file 'src/ubuntumirclient/desktopwindow.h' => 'src/ubuntumirclient/qmirclientdesktopwindow.h'
--- src/ubuntumirclient/desktopwindow.h	2016-10-04 16:20:07 +0000
+++ src/ubuntumirclient/qmirclientdesktopwindow.h	2017-02-21 12:29:19 +0000
@@ -1,29 +1,53 @@
-/*
- * 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
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTDESKTOPWINDOW_H
+#define QMIRCLIENTDESKTOPWINDOW_H
 
 #include <qpa/qplatformwindow.h>
 
 // TODO Implement it. For now it's just an empty, dummy class.
-class UbuntuDesktopWindow : public QPlatformWindow
+class QMirClientDesktopWindow : public QPlatformWindow
 {
 public:
-    UbuntuDesktopWindow(QWindow*);
+    QMirClientDesktopWindow(QWindow*);
 };
 
-#endif // UBUNTU_DESKTOP_WINDOW_H
+#endif // QMIRCLIENTDESKTOPWINDOW_H

=== renamed file 'src/ubuntumirclient/glcontext.cpp' => 'src/ubuntumirclient/qmirclientglcontext.cpp'
--- src/ubuntumirclient/glcontext.cpp	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientglcontext.cpp	2017-02-21 12:29:19 +0000
@@ -1,29 +1,53 @@
-/*
- * 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
- * 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 "glcontext.h"
-#include "logging.h"
-#include "window.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientglcontext.h"
+#include "qmirclientlogging.h"
+#include "qmirclientwindow.h"
 
 #include <QOpenGLFramebufferObject>
 #include <QtPlatformSupport/private/qeglconvenience_p.h>
 #include <QtPlatformSupport/private/qeglpbuffer_p.h>
 #include <QtGui/private/qopenglcontext_p.h>
 
-Q_LOGGING_CATEGORY(ubuntumirclientGraphics, "ubuntumirclient.graphics", QtWarningMsg)
+Q_LOGGING_CATEGORY(mirclientGraphics, "qt.qpa.mirclient.graphics", QtWarningMsg)
 
 namespace {
 
@@ -33,25 +57,25 @@
     Q_ASSERT(config != nullptr);
 
     const char *string = eglQueryString(display, EGL_VENDOR);
-    qCDebug(ubuntumirclientGraphics, "EGL vendor: %s", string);
+    qCDebug(mirclientGraphics, "EGL vendor: %s", string);
 
     string = eglQueryString(display, EGL_VERSION);
-    qCDebug(ubuntumirclientGraphics, "EGL version: %s", string);
+    qCDebug(mirclientGraphics, "EGL version: %s", string);
 
     string = eglQueryString(display, EGL_EXTENSIONS);
-    qCDebug(ubuntumirclientGraphics, "EGL extensions: %s", string);
+    qCDebug(mirclientGraphics, "EGL extensions: %s", string);
 
-    qCDebug(ubuntumirclientGraphics, "EGL configuration attributes:");
+    qCDebug(mirclientGraphics, "EGL configuration attributes:");
     q_printEglConfig(display, config);
 }
 
 } // anonymous namespace
 
-UbuntuOpenGLContext::UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
+QMirClientOpenGLContext::QMirClientOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
                                          EGLDisplay display)
     : QEGLPlatformContext(format, share, display, 0)
 {
-    if (ubuntumirclientGraphics().isDebugEnabled()) {
+    if (mirclientGraphics().isDebugEnabled()) {
         printEglConfig(display, eglConfig());
     }
 }
@@ -72,7 +96,7 @@
     return needsWorkaround;
 }
 
-bool UbuntuOpenGLContext::makeCurrent(QPlatformSurface* surface)
+bool QMirClientOpenGLContext::makeCurrent(QPlatformSurface* surface)
 {
     const bool ret = QEGLPlatformContext::makeCurrent(surface);
 
@@ -86,23 +110,23 @@
 }
 
 // Following method used internally in the base class QEGLPlatformContext to access
-// the egl surface of a QPlatformSurface/UbuntuWindow
-EGLSurface UbuntuOpenGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
+// the egl surface of a QPlatformSurface/QMirClientWindow
+EGLSurface QMirClientOpenGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
 {
     if (surface->surface()->surfaceClass() == QSurface::Window) {
-        return static_cast<UbuntuWindow *>(surface)->eglSurface();
+        return static_cast<QMirClientWindow *>(surface)->eglSurface();
     } else {
         return static_cast<QEGLPbuffer *>(surface)->pbuffer();
     }
 }
 
-void UbuntuOpenGLContext::swapBuffers(QPlatformSurface *surface)
+void QMirClientOpenGLContext::swapBuffers(QPlatformSurface *surface)
 {
     QEGLPlatformContext::swapBuffers(surface);
 
     if (surface->surface()->surfaceClass() == QSurface::Window) {
         // notify window on swap completion
-        auto ubuntuWindow = static_cast<UbuntuWindow *>(surface);
-        ubuntuWindow->onSwapBuffersDone();
+        auto platformWindow = static_cast<QMirClientWindow *>(surface);
+        platformWindow->onSwapBuffersDone();
     }
 }

=== renamed file 'src/ubuntumirclient/glcontext.h' => 'src/ubuntumirclient/qmirclientglcontext.h'
--- src/ubuntumirclient/glcontext.h	2016-07-21 11:55:40 +0000
+++ src/ubuntumirclient/qmirclientglcontext.h	2017-02-21 12:29:19 +0000
@@ -1,31 +1,55 @@
-/*
- * 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
- * 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_OPENGL_CONTEXT_H
-#define UBUNTU_OPENGL_CONTEXT_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTGLCONTEXT_H
+#define QMIRCLIENTGLCONTEXT_H
 
 #include <qpa/qplatformopenglcontext.h>
-#include <private/qeglplatformcontext_p.h>
+#include <QtPlatformSupport/private/qeglplatformcontext_p.h>
 
 #include <EGL/egl.h>
 
-class UbuntuOpenGLContext : public QEGLPlatformContext
+class QMirClientOpenGLContext : public QEGLPlatformContext
 {
 public:
-    UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
+    QMirClientOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
                         EGLDisplay display);
 
     // QEGLPlatformContext methods.
@@ -36,4 +60,4 @@
     EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) final;
 };
 
-#endif // UBUNTU_OPENGL_CONTEXT_H
+#endif // QMIRCLIENTGLCONTEXT_H

=== renamed file 'src/ubuntumirclient/input.cpp' => 'src/ubuntumirclient/qmirclientinput.cpp'
--- src/ubuntumirclient/input.cpp	2017-01-10 06:41:48 +0000
+++ src/ubuntumirclient/qmirclientinput.cpp	2017-02-21 12:29:19 +0000
@@ -1,33 +1,57 @@
-/*
- * 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
- * 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/>.
- */
+/****************************************************************************
+**
+** Copyright (C) 2014-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
 
 // Local
-#include "input.h"
-#include "integration.h"
-#include "nativeinterface.h"
-#include "screen.h"
-#include "window.h"
-#include "logging.h"
-#include "orientationchangeevent_p.h"
+#include "qmirclientinput.h"
+#include "qmirclientintegration.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientwindow.h"
+#include "qmirclientlogging.h"
+#include "qmirclientorientationchangeevent_p.h"
 
 // Qt
 #include <QtCore/QThread>
 #include <QtCore/qglobal.h>
 #include <QtCore/QCoreApplication>
-#include <private/qguiapplication_p.h>
+#include <QtGui/private/qguiapplication_p.h>
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qwindowsysteminterface.h>
 #include <QTextCodec>
@@ -37,7 +61,7 @@
 
 #include <mir_toolkit/mir_client_library.h>
 
-Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntumirclient.input", QtWarningMsg)
+Q_LOGGING_CATEGORY(mirclientInput, "qt.qpa.mirclient.input", QtWarningMsg)
 
 namespace
 {
@@ -143,22 +167,22 @@
     0,                          0
 };
 
-Qt::WindowState mirSurfaceStateToWindowState(MirSurfaceState state)
+Qt::WindowState mirWindowStateToQt(MirWindowState state)
 {
     switch (state) {
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
         return Qt::WindowFullScreen;
-    case mir_surface_state_maximized:
-    case mir_surface_state_vertmaximized:
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_maximized:
+    case mir_window_state_vertmaximized:
+    case mir_window_state_horizmaximized:
         return Qt::WindowMaximized;
-    case mir_surface_state_minimized:
+    case mir_window_state_minimized:
         return Qt::WindowMinimized;
-    case mir_surface_state_hidden:
+    case mir_window_state_hidden:
         // We should be handling this state separately.
         Q_ASSERT(false);
-    case mir_surface_state_restored:
-    case mir_surface_state_unknown:
+    case mir_window_state_restored:
+    case mir_window_state_unknown:
     default:
         return Qt::WindowNoState;
     }
@@ -169,7 +193,7 @@
 class UbuntuEvent : public QEvent
 {
 public:
-    UbuntuEvent(UbuntuWindow* window, const MirEvent *event, QEvent::Type type)
+    UbuntuEvent(QMirClientWindow* window, const MirEvent *event, QEvent::Type type)
         : QEvent(type), window(window) {
         nativeEvent = mir_event_ref(event);
     }
@@ -178,14 +202,14 @@
         mir_event_unref(nativeEvent);
     }
 
-    QPointer<UbuntuWindow> window;
+    QPointer<QMirClientWindow> window;
     const MirEvent *nativeEvent;
 };
 
-UbuntuInput::UbuntuInput(UbuntuClientIntegration* integration)
+QMirClientInput::QMirClientInput(QMirClientClientIntegration* integration)
     : QObject(nullptr)
     , mIntegration(integration)
-    , mEventFilterType(static_cast<UbuntuNativeInterface*>(
+    , mEventFilterType(static_cast<QMirClientNativeInterface*>(
         integration->nativeInterface())->genericEventFilterType())
     , mEventType(static_cast<QEvent::Type>(QEvent::registerEventType()))
     , mLastInputWindow(nullptr)
@@ -199,7 +223,7 @@
     QWindowSystemInterface::registerTouchDevice(mTouchDevice);
 }
 
-UbuntuInput::~UbuntuInput()
+QMirClientInput::~QMirClientInput()
 {
   // Qt will take care of deleting mTouchDevice.
 }
@@ -212,40 +236,40 @@
         return "key";
     case mir_event_type_motion:
         return "motion";
-    case mir_event_type_surface:
-        return "surface";
+    case mir_event_type_window:
+        return "window";
     case mir_event_type_resize:
         return "resize";
     case mir_event_type_prompt_session_state_change:
         return "prompt_session_state_change";
     case mir_event_type_orientation:
         return "orientation";
-    case mir_event_type_close_surface:
-        return "close_surface";
+    case mir_event_type_close_window:
+        return "close_window";
     case mir_event_type_input:
         return "input";
     case mir_event_type_keymap:
         return "keymap";
-    case mir_event_type_input_configuration:
-        return "input_configuration";
-    case mir_event_type_surface_output:
-        return "surface_output";
+    case mir_event_type_window_output:
+        return "window_output";
     case mir_event_type_input_device_state:
         return "input_device_state";
-    case mir_event_type_surface_placement:
-        return "surface_placement";
+    case mir_event_type_window_placement:
+        return "window_placement";
+    default:
+        Q_UNREACHABLE();
     }
     Q_UNREACHABLE();
 }
 
-void UbuntuInput::customEvent(QEvent* event)
+void QMirClientInput::customEvent(QEvent* event)
 {
     Q_ASSERT(QThread::currentThread() == thread());
     UbuntuEvent* ubuntuEvent = static_cast<UbuntuEvent*>(event);
     const MirEvent *nativeEvent = ubuntuEvent->nativeEvent;
 
     if ((ubuntuEvent->window == nullptr) || (ubuntuEvent->window->window() == nullptr)) {
-        qCWarning(ubuntumirclient) << "Attempted to deliver an event to a non-existent window, ignoring.";
+        qCWarning(mirclient) << "Attempted to deliver an event to a non-existent window, ignoring.";
         return;
     }
 
@@ -254,11 +278,11 @@
     if (QWindowSystemInterface::handleNativeEvent(
             ubuntuEvent->window->window(), mEventFilterType,
             const_cast<void *>(static_cast<const void *>(nativeEvent)), &result) == true) {
-        qCDebug(ubuntumirclient, "event filtered out by native interface");
+        qCDebug(mirclient, "event filtered out by native interface");
         return;
     }
 
-    qCDebug(ubuntumirclientInput, "customEvent(type=%s)", nativeEventTypeToStr(mir_event_get_type(nativeEvent)));
+    qCDebug(mirclientInput, "customEvent(type=%s)", nativeEventTypeToStr(mir_event_get_type(nativeEvent)));
 
     // Event dispatching.
     switch (mir_event_get_type(nativeEvent))
@@ -273,7 +297,7 @@
         // Enable workaround for Screen rotation
         auto const targetWindow = ubuntuEvent->window;
         if (targetWindow) {
-            auto const screen = static_cast<UbuntuScreen*>(targetWindow->screen());
+            auto const screen = static_cast<QMirClientScreen*>(targetWindow->screen());
             if (screen) {
                 screen->handleWindowSurfaceResize(
                         mir_resize_event_get_width(resizeEvent),
@@ -286,24 +310,24 @@
         }
         break;
     }
-    case mir_event_type_surface:
-        handleSurfaceEvent(ubuntuEvent->window, mir_event_get_surface_event(nativeEvent));
+    case mir_event_type_window:
+        handleWindowEvent(ubuntuEvent->window, mir_event_get_window_event(nativeEvent));
         break;
-    case mir_event_type_surface_output:
-        handleSurfaceOutputEvent(ubuntuEvent->window, mir_event_get_surface_output_event(nativeEvent));
+    case mir_event_type_window_output:
+        handleWindowOutputEvent(ubuntuEvent->window, mir_event_get_window_output_event(nativeEvent));
         break;
     case mir_event_type_orientation:
         dispatchOrientationEvent(ubuntuEvent->window->window(), mir_event_get_orientation_event(nativeEvent));
         break;
-    case mir_event_type_close_surface:
+    case mir_event_type_close_window:
         QWindowSystemInterface::handleCloseEvent(ubuntuEvent->window->window());
         break;
     default:
-        qCDebug(ubuntumirclient, "unhandled event type: %d", static_cast<int>(mir_event_get_type(nativeEvent)));
+        qCDebug(mirclient, "unhandled event type: %d", static_cast<int>(mir_event_get_type(nativeEvent)));
     }
 }
 
-void UbuntuInput::postEvent(UbuntuWindow *platformWindow, const MirEvent *event)
+void QMirClientInput::postEvent(QMirClientWindow *platformWindow, const MirEvent *event)
 {
     QWindow *window = platformWindow->window();
 
@@ -312,12 +336,12 @@
 
     if ((window->flags().testFlag(Qt::WindowTransparentForInput)) && window->parent()) {
         QCoreApplication::postEvent(this, new UbuntuEvent(
-                    static_cast<UbuntuWindow*>(platformWindow->QPlatformWindow::parent()),
+                    static_cast<QMirClientWindow*>(platformWindow->QPlatformWindow::parent()),
                     event, mEventType));
     }
 }
 
-void UbuntuInput::dispatchInputEvent(UbuntuWindow *window, const MirInputEvent *ev)
+void QMirClientInput::dispatchInputEvent(QMirClientWindow *window, const MirInputEvent *ev)
 {
     switch (mir_input_event_get_type(ev))
     {
@@ -335,7 +359,7 @@
     }
 }
 
-void UbuntuInput::dispatchTouchEvent(UbuntuWindow *window, const MirInputEvent *ev)
+void QMirClientInput::dispatchTouchEvent(QMirClientWindow *window, const MirInputEvent *ev)
 {
     const MirTouchEvent *tev = mir_input_event_get_touch_event(ev);
 
@@ -433,7 +457,7 @@
 }
 }
 
-void UbuntuInput::dispatchKeyEvent(UbuntuWindow *window, const MirInputEvent *event)
+void QMirClientInput::dispatchKeyEvent(QMirClientWindow *window, const MirInputEvent *event)
 {
     const MirKeyboardEvent *key_event = mir_input_event_get_keyboard_event(event);
 
@@ -470,7 +494,7 @@
         QKeyEvent qKeyEvent(keyType, sym, modifiers, scan_code, xk_sym, native_modifiers, text, is_auto_rep);
         qKeyEvent.setTimestamp(timestamp);
         if (context->filterEvent(&qKeyEvent)) {
-            qCDebug(ubuntumirclient, "key event filtered out by input context");
+            qCDebug(mirclient, "key event filtered out by input context");
             return;
         }
     }
@@ -498,7 +522,7 @@
 }
 }
 
-void UbuntuInput::dispatchPointerEvent(UbuntuWindow *platformWindow, const MirInputEvent *ev)
+void QMirClientInput::dispatchPointerEvent(QMirClientWindow *platformWindow, const MirInputEvent *ev)
 {
     const auto window = platformWindow->window();
     const auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
@@ -557,13 +581,13 @@
     Q_UNREACHABLE();
 }
 
-void UbuntuInput::dispatchOrientationEvent(QWindow *window, const MirOrientationEvent *event)
+void QMirClientInput::dispatchOrientationEvent(QWindow *window, const MirOrientationEvent *event)
 {
     MirOrientation mir_orientation = mir_orientation_event_get_direction(event);
-    qCDebug(ubuntumirclientInput, "orientation direction: %s", nativeOrientationDirectionToStr(mir_orientation));
+    qCDebug(mirclientInput, "orientation direction: %s", nativeOrientationDirectionToStr(mir_orientation));
 
     if (!window->screen()) {
-        qCDebug(ubuntumirclient, "Window has no associated screen, dropping orientation event");
+        qCDebug(mirclient, "Window has no associated screen, dropping orientation event");
         return;
     }
 
@@ -582,7 +606,7 @@
         orientation = OrientationChangeEvent::RightUp;
         break;
     default:
-        qCDebug(ubuntumirclient, "No such orientation %d", mir_orientation);
+        qCDebug(mirclient, "No such orientation %d", mir_orientation);
         return;
     }
 
@@ -590,57 +614,58 @@
     // notifying Qt of the actual orientation change - done to prevent multiple Windows each creating
     // an identical orientation change event and passing it directly to Qt.
     // [Platform]Screen can also factor in the native orientation.
-    QCoreApplication::postEvent(static_cast<UbuntuScreen*>(window->screen()->handle()),
+    QCoreApplication::postEvent(static_cast<QMirClientScreen*>(window->screen()->handle()),
                                 new OrientationChangeEvent(OrientationChangeEvent::mType, orientation));
 }
 
-void UbuntuInput::handleSurfaceEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceEvent *event)
+void QMirClientInput::handleWindowEvent(const QPointer<QMirClientWindow> &window, const MirWindowEvent *event)
 {
-    auto surfaceEventAttribute = mir_surface_event_get_attribute(event);
+    auto windowEventAttribute = mir_window_event_get_attribute(event);
 
-    switch (surfaceEventAttribute) {
-    case mir_surface_attrib_focus: {
+    switch (windowEventAttribute) {
+    case mir_window_attrib_focus: {
         window->handleSurfaceFocusChanged(
-                    mir_surface_event_get_attribute_value(event) == mir_surface_focused);
+                    mir_window_event_get_attribute_value(event) == mir_window_focus_state_focused);
         break;
     }
-    case mir_surface_attrib_visibility:
+    case mir_window_attrib_visibility: {
         window->handleSurfaceExposeChange(
-                    mir_surface_event_get_attribute_value(event) == mir_surface_visibility_exposed);
+                    mir_window_event_get_attribute_value(event) == mir_window_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(event));
+    case mir_window_attrib_state: {
+        MirWindowState state = static_cast<MirWindowState>(mir_window_event_get_attribute_value(event));
 
-        if (state == mir_surface_state_hidden) {
+        if (state == mir_window_state_hidden) {
             window->handleSurfaceVisibilityChanged(false);
         } else {
             // it's visible!
             window->handleSurfaceVisibilityChanged(true);
-            window->handleSurfaceStateChanged(mirSurfaceStateToWindowState(state));
+            window->handleSurfaceStateChanged(mirWindowStateToQt(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:
+    case mir_window_attrib_type:
+    case mir_window_attrib_swapinterval:
+    case mir_window_attrib_dpi:
+    case mir_window_attrib_preferred_orientation:
+    case mir_window_attribs:
         break;
     }
 }
 
-void UbuntuInput::handleSurfaceOutputEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceOutputEvent *event)
+void QMirClientInput::handleWindowOutputEvent(const QPointer<QMirClientWindow> &window, const MirWindowOutputEvent *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 uint32_t outputId = mir_window_output_event_get_output_id(event);
+    const int dpi = mir_window_output_event_get_dpi(event);
+    const MirFormFactor formFactor = mir_window_output_event_get_form_factor(event);
+    const float scale = mir_window_output_event_get_scale(event);
 
     const auto screenObserver = mIntegration->screenObserver();
-    UbuntuScreen *screen = screenObserver->findScreenWithId(outputId);
+    QMirClientScreen *screen = screenObserver->findScreenWithId(outputId);
     if (!screen) {
-        qCWarning(ubuntumirclient) << "Mir notified window" << window->window() << "on an unknown screen with id" << outputId;
+        qCWarning(mirclient) << "Mir notified window" << window->window() << "on an unknown screen with id" << outputId;
         return;
     }
 

=== renamed file 'src/ubuntumirclient/input.h' => 'src/ubuntumirclient/qmirclientinput.h'
--- src/ubuntumirclient/input.h	2016-09-21 10:25:33 +0000
+++ src/ubuntumirclient/qmirclientinput.h	2017-02-21 12:29:19 +0000
@@ -1,63 +1,86 @@
-/*
- * 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
- * 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_INPUT_H
-#define UBUNTU_INPUT_H
+/****************************************************************************
+**
+** Copyright (C) 2014-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTINPUT_H
+#define QMIRCLIENTINPUT_H
 
 // Qt
 #include <qpa/qwindowsysteminterface.h>
-#include <QLoggingCategory>
 
 #include <mir_toolkit/mir_client_library.h>
 
-class UbuntuClientIntegration;
-class UbuntuWindow;
+class QMirClientClientIntegration;
+class QMirClientWindow;
 
-class UbuntuInput : public QObject
+class QMirClientInput : public QObject
 {
     Q_OBJECT
 
 public:
-    UbuntuInput(UbuntuClientIntegration* integration);
-    virtual ~UbuntuInput();
+    QMirClientInput(QMirClientClientIntegration* integration);
+    virtual ~QMirClientInput();
 
     // QObject methods.
     void customEvent(QEvent* event) override;
 
-    void postEvent(UbuntuWindow* window, const MirEvent *event);
-    UbuntuClientIntegration* integration() const { return mIntegration; }
-    UbuntuWindow *lastInputWindow() const {return mLastInputWindow; }
+    void postEvent(QMirClientWindow* window, const MirEvent *event);
+    QMirClientClientIntegration* integration() const { return mIntegration; }
+    QMirClientWindow *lastInputWindow() const {return mLastInputWindow; }
 
 protected:
-    void dispatchKeyEvent(UbuntuWindow *window, const MirInputEvent *event);
-    void dispatchPointerEvent(UbuntuWindow *window, const MirInputEvent *event);
-    void dispatchTouchEvent(UbuntuWindow *window, const MirInputEvent *event);
-    void dispatchInputEvent(UbuntuWindow *window, const MirInputEvent *event);
+    void dispatchKeyEvent(QMirClientWindow *window, const MirInputEvent *event);
+    void dispatchPointerEvent(QMirClientWindow *window, const MirInputEvent *event);
+    void dispatchTouchEvent(QMirClientWindow *window, const MirInputEvent *event);
+    void dispatchInputEvent(QMirClientWindow *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);
+    void handleWindowEvent(const QPointer<QMirClientWindow> &window, const MirWindowEvent *event);
+    void handleWindowOutputEvent(const QPointer<QMirClientWindow> &window, const MirWindowOutputEvent *event);
 
 private:
-    UbuntuClientIntegration* mIntegration;
+    QMirClientClientIntegration* mIntegration;
     QTouchDevice* mTouchDevice;
     const QByteArray mEventFilterType;
     const QEvent::Type mEventType;
 
-    UbuntuWindow *mLastInputWindow;
+    QMirClientWindow *mLastInputWindow;
 };
 
-#endif // UBUNTU_INPUT_H
+#endif // QMIRCLIENTINPUT_H

=== renamed file 'src/ubuntumirclient/integration.cpp' => 'src/ubuntumirclient/qmirclientintegration.cpp'
--- src/ubuntumirclient/integration.cpp	2017-01-19 22:54:37 +0000
+++ src/ubuntumirclient/qmirclientintegration.cpp	2017-02-21 12:29:19 +0000
@@ -1,36 +1,59 @@
-/*
- * 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
- * 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/>.
- */
+/****************************************************************************
+**
+** Copyright (C) 2014-2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
 
 // Local
-#include "integration.h"
-#include "backingstore.h"
-#include "clipboard.h"
-#include "desktopwindow.h"
-#include "debugextension.h"
-#include "glcontext.h"
-#include "input.h"
-#include "logging.h"
-#include "nativeinterface.h"
-#include "screen.h"
-#include "window.h"
+#include "qmirclientintegration.h"
+#include "qmirclientbackingstore.h"
+#include "qmirclientclipboard.h"
+#include "qmirclientdebugextension.h"
+#include "qmirclientdesktopwindow.h"
+#include "qmirclientglcontext.h"
+#include "qmirclientinput.h"
+#include "qmirclientlogging.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientwindow.h"
 
 // Qt
 #include <QFileInfo>
 #include <QGuiApplication>
-#include <private/qeglpbuffer_p.h>
 #include <qpa/qplatformnativeinterface.h>
 #include <qpa/qplatforminputcontextfactory_p.h>
 #include <qpa/qplatforminputcontext.h>
@@ -71,29 +94,29 @@
 
 static void resumedCallback(const UApplicationOptions */*options*/, void *context)
 {
-    auto integration = static_cast<UbuntuClientIntegration*>(context);
+    auto integration = static_cast<QMirClientClientIntegration*>(context);
     integration->appStateController()->setResumed();
 }
 
 static void aboutToStopCallback(UApplicationArchive */*archive*/, void *context)
 {
-    auto integration = static_cast<UbuntuClientIntegration*>(context);
+    auto integration = static_cast<QMirClientClientIntegration*>(context);
     auto inputContext = integration->inputContext();
     if (inputContext) {
         inputContext->hideInputPanel();
     } else {
-        qCWarning(ubuntumirclient) << "aboutToStopCallback(): no input context";
+        qCWarning(mirclient) << "aboutToStopCallback(): no input context";
     }
     integration->appStateController()->setSuspended();
 }
 
 
-UbuntuClientIntegration::UbuntuClientIntegration(int argc, char **argv)
+QMirClientClientIntegration::QMirClientClientIntegration(int argc, char **argv)
     : QPlatformIntegration()
-    , mNativeInterface(new UbuntuNativeInterface(this))
+    , mNativeInterface(new QMirClientNativeInterface(this))
     , mFontDb(new QGenericUnixFontDatabase)
-    , mServices(new UbuntuPlatformServices)
-    , mAppStateController(new UbuntuAppStateController)
+    , mServices(new QMirClientPlatformServices)
+    , mAppStateController(new QMirClientAppStateController)
     , mScaleFactor(1.0)
 {
     QByteArray sessionName;
@@ -108,7 +131,7 @@
     mInstance = u_application_instance_new_from_description_with_options(mDesc, mOptions);
 
     if (mInstance == nullptr) {
-        qCritical("[QPA] UbuntuClientIntegration: connection to Mir server failed.\n");
+        qCritical("[QPA] QMirClientClientIntegration: connection to Mir server failed.\n");
 
         // TODO: add API to platform-api to fetch Mir's error message (bug:1655970).
         // Workaround by retrying the connection here in order to get the message.
@@ -140,28 +163,28 @@
         }
     }
     if (testability) {
-        mDebugExtension.reset(new UbuntuDebugExtension);
+        mDebugExtension.reset(new QMirClientDebugExtension);
         if (!mDebugExtension->isEnabled()) {
             mDebugExtension.reset();
         }
     }
 }
 
-void UbuntuClientIntegration::initialize()
+void QMirClientClientIntegration::initialize()
 {
     // Init the ScreenObserver
-    mScreenObserver.reset(new UbuntuScreenObserver(mMirConnection));
-    connect(mScreenObserver.data(), &UbuntuScreenObserver::screenAdded,
-            [this](UbuntuScreen *screen) { this->screenAdded(screen); });
-    connect(mScreenObserver.data(), &UbuntuScreenObserver::screenRemoved,
-                     this, &UbuntuClientIntegration::destroyScreen);
+    mScreenObserver.reset(new QMirClientScreenObserver(mMirConnection));
+    connect(mScreenObserver.data(), &QMirClientScreenObserver::screenAdded,
+            [this](QMirClientScreen *screen) { this->screenAdded(screen); });
+    connect(mScreenObserver.data(), &QMirClientScreenObserver::screenRemoved,
+                     this, &QMirClientClientIntegration::destroyScreen);
 
-    Q_FOREACH(auto screen, mScreenObserver->screens()) {
+    Q_FOREACH (auto screen, mScreenObserver->screens()) {
         screenAdded(screen);
     }
 
     // Initialize input.
-    mInput = new UbuntuInput(this);
+    mInput = new QMirClientInput(this);
     mInputContext = QPlatformInputContextFactory::create();
 
     // compute the scale factor
@@ -178,7 +201,7 @@
     mScaleFactor = static_cast<qreal>(gridUnit) / defaultGridUnit;
 }
 
-UbuntuClientIntegration::~UbuntuClientIntegration()
+QMirClientClientIntegration::~QMirClientClientIntegration()
 {
     eglTerminate(mEglDisplay);
     delete mInput;
@@ -186,12 +209,12 @@
     delete mServices;
 }
 
-QPlatformServices *UbuntuClientIntegration::services() const
+QPlatformServices *QMirClientClientIntegration::services() const
 {
     return mServices;
 }
 
-void UbuntuClientIntegration::setupOptions(QStringList &args)
+void QMirClientClientIntegration::setupOptions(QStringList &args)
 {
     int argc = args.size() + 1;
     char **argv = new char*[argc];
@@ -206,7 +229,7 @@
     delete [] argv;
 }
 
-void UbuntuClientIntegration::setupDescription(QByteArray &sessionName)
+void QMirClientClientIntegration::setupDescription(QByteArray &sessionName)
 {
     mDesc = u_application_description_new();
 
@@ -220,7 +243,7 @@
     u_application_description_set_application_lifecycle_delegate(mDesc, delegate);
 }
 
-QByteArray UbuntuClientIntegration::generateSessionName(QStringList &args)
+QByteArray QMirClientClientIntegration::generateSessionName(QStringList &args)
 {
     // Try to come up with some meaningful session name to uniquely identify this session,
     // helping with shell debugging
@@ -236,7 +259,7 @@
     }
 }
 
-QByteArray UbuntuClientIntegration::generateSessionNameFromQmlFile(QStringList &args)
+QByteArray QMirClientClientIntegration::generateSessionNameFromQmlFile(QStringList &args)
 {
     Q_FOREACH (QString arg, args) {
         if (arg.endsWith(".qml")) {
@@ -249,25 +272,25 @@
     return "qmlscene";
 }
 
-QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window) const
+QPlatformWindow* QMirClientClientIntegration::createPlatformWindow(QWindow* window) const
 {
     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);
+        return new QMirClientDesktopWindow(window);
     } else {
-        return new UbuntuWindow(window, mInput, mNativeInterface, mAppStateController.data(),
-                                mEglDisplay, mMirConnection, mDebugExtension.data());
+        return new QMirClientWindow(window, mInput, mNativeInterface, mAppStateController.data(),
+                                    mEglDisplay, mMirConnection, mDebugExtension.data());
     }
 }
 
-bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
+bool QMirClientClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
 {
     switch (cap) {
     case ThreadedOpenGL:
         if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_THREADED_OPENGL")) {
             return true;
         } else {
-            qCDebug(ubuntumirclient, "disabled threaded OpenGL");
+            qCDebug(mirclient, "disabled threaded OpenGL");
             return false;
         }
 
@@ -286,52 +309,52 @@
     }
 }
 
-QAbstractEventDispatcher *UbuntuClientIntegration::createEventDispatcher() const
+QAbstractEventDispatcher *QMirClientClientIntegration::createEventDispatcher() const
 {
     return createUnixEventDispatcher();
 }
 
-QPlatformBackingStore* UbuntuClientIntegration::createPlatformBackingStore(QWindow* window) const
+QPlatformBackingStore* QMirClientClientIntegration::createPlatformBackingStore(QWindow* window) const
 {
-    return new UbuntuBackingStore(window);
+    return new QMirClientBackingStore(window);
 }
 
-QPlatformOpenGLContext* UbuntuClientIntegration::createPlatformOpenGLContext(
+QPlatformOpenGLContext* QMirClientClientIntegration::createPlatformOpenGLContext(
         QOpenGLContext* context) const
 {
     QSurfaceFormat format(context->format());
 
-    auto platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
+    auto platformContext = new QMirClientOpenGLContext(format, context->shareHandle(), mEglDisplay);
     if (!platformContext->isValid()) {
         // 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
+        // 1.4 context, but the XCB EGL backend tries to honor 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(mEglDisplay, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
         if (isMesa) {
-            qCDebug(ubuntumirclientGraphics, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
+            qCDebug(mirclientGraphics, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
             format.setMajorVersion(1);
             format.setMinorVersion(4);
             delete platformContext;
-            platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
+            platformContext = new QMirClientOpenGLContext(format, context->shareHandle(), mEglDisplay);
         }
     }
     return platformContext;
 }
 
-QStringList UbuntuClientIntegration::themeNames() const
+QStringList QMirClientClientIntegration::themeNames() const
 {
     return QStringList(QStringLiteral("ubuntuappmenu"));
 }
 
-QPlatformTheme* UbuntuClientIntegration::createPlatformTheme(const QString& name) const
+QPlatformTheme* QMirClientClientIntegration::createPlatformTheme(const QString& name) const
 {
     Q_UNUSED(name);
     return new UbuntuIconTheme;
 }
 
-QVariant UbuntuClientIntegration::styleHint(StyleHint hint) const
+QVariant QMirClientClientIntegration::styleHint(StyleHint hint) const
 {
     switch (hint) {
         case QPlatformIntegration::StartDragDistance: {
@@ -348,27 +371,27 @@
     return QPlatformIntegration::styleHint(hint);
 }
 
-QPlatformClipboard* UbuntuClientIntegration::clipboard() const
+QPlatformClipboard* QMirClientClientIntegration::clipboard() const
 {
     static QPlatformClipboard *clipboard = nullptr;
     if (!clipboard) {
-        clipboard = new UbuntuClipboard;
+        clipboard = new QMirClientClipboard;
     }
     return clipboard;
 }
 
-QPlatformNativeInterface* UbuntuClientIntegration::nativeInterface() const
+QPlatformNativeInterface* QMirClientClientIntegration::nativeInterface() const
 {
     return mNativeInterface;
 }
 
-QPlatformOffscreenSurface *UbuntuClientIntegration::createPlatformOffscreenSurface(
+QPlatformOffscreenSurface *QMirClientClientIntegration::createPlatformOffscreenSurface(
         QOffscreenSurface *surface) const
 {
     return new QEGLPbuffer(mEglDisplay, surface->requestedFormat(), surface);
 }
 
-void UbuntuClientIntegration::destroyScreen(UbuntuScreen *screen)
+void QMirClientClientIntegration::destroyScreen(QMirClientScreen *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
@@ -391,7 +414,7 @@
         }
     }
 
-    qCDebug(ubuntumirclient) << "Removing Screen with id" << screen->mirOutputId() << "and geometry" << screen->geometry();
+    qCDebug(mirclient) << "Removing Screen with id" << screen->mirOutputId() << "and geometry" << screen->geometry();
 #if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
     delete screen;
 #else
@@ -399,7 +422,7 @@
 #endif
 }
 
-QPlatformAccessibility *UbuntuClientIntegration::accessibility() const
+QPlatformAccessibility *QMirClientClientIntegration::accessibility() const
 {
     if (!mAccessibility) {
         mAccessibility.reset(new QSpiAccessibleBridge());

=== renamed file 'src/ubuntumirclient/integration.h' => 'src/ubuntumirclient/qmirclientintegration.h'
--- src/ubuntumirclient/integration.h	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientintegration.h	2017-02-21 12:29:19 +0000
@@ -1,28 +1,52 @@
-/*
- * 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
- * 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_CLIENT_INTEGRATION_H
-#define UBUNTU_CLIENT_INTEGRATION_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTINTEGRATION_H
+#define QMIRCLIENTINTEGRATION_H
 
 #include <qpa/qplatformintegration.h>
 #include <QSharedPointer>
 
-#include "appstatecontroller.h"
-#include "platformservices.h"
-#include "screenobserver.h"
+#include "qmirclientappstatecontroller.h"
+#include "qmirclientplatformservices.h"
+#include "qmirclientscreenobserver.h"
 
 // platform-api
 #include <ubuntu/application/description.h>
@@ -30,19 +54,19 @@
 
 #include <EGL/egl.h>
 
-class UbuntuDebugExtension;
-class UbuntuInput;
-class UbuntuNativeInterface;
-class UbuntuScreen;
+class QMirClientDebugExtension;
+class QMirClientInput;
+class QMirClientNativeInterface;
+class QMirClientScreen;
 class MirConnection;
 
-class UbuntuClientIntegration : public QObject, public QPlatformIntegration
+class QMirClientClientIntegration : public QObject, public QPlatformIntegration
 {
     Q_OBJECT
 
 public:
-    UbuntuClientIntegration(int argc, char **argv);
-    virtual ~UbuntuClientIntegration();
+    QMirClientClientIntegration(int argc, char **argv);
+    virtual ~QMirClientClientIntegration();
 
     // QPlatformIntegration methods.
     bool hasCapability(QPlatformIntegration::Capability cap) const override;
@@ -66,12 +90,12 @@
     MirConnection *mirConnection() const { return mMirConnection; }
     EGLDisplay eglDisplay() const { return mEglDisplay; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
-    UbuntuAppStateController *appStateController() const { return mAppStateController.data(); }
-    UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
-    UbuntuDebugExtension *debugExtension() const { return mDebugExtension.data(); }
+    QMirClientAppStateController *appStateController() const { return mAppStateController.data(); }
+    QMirClientScreenObserver *screenObserver() const { return mScreenObserver.data(); }
+    QMirClientDebugExtension *debugExtension() const { return mDebugExtension.data(); }
 
 private Q_SLOTS:
-    void destroyScreen(UbuntuScreen *screen);
+    void destroyScreen(QMirClientScreen *screen);
 
 private:
     void setupOptions(QStringList &args);
@@ -79,17 +103,17 @@
     static QByteArray generateSessionName(QStringList &args);
     static QByteArray generateSessionNameFromQmlFile(QStringList &args);
 
-    UbuntuNativeInterface* mNativeInterface;
+    QMirClientNativeInterface* mNativeInterface;
     QPlatformFontDatabase* mFontDb;
 
-    UbuntuPlatformServices* mServices;
+    QMirClientPlatformServices* mServices;
 
-    UbuntuInput* mInput;
+    QMirClientInput* mInput;
     QPlatformInputContext* mInputContext;
     mutable QScopedPointer<QPlatformAccessibility> mAccessibility;
-    QScopedPointer<UbuntuDebugExtension> mDebugExtension;
-    QScopedPointer<UbuntuScreenObserver> mScreenObserver;
-    QScopedPointer<UbuntuAppStateController> mAppStateController;
+    QScopedPointer<QMirClientDebugExtension> mDebugExtension;
+    QScopedPointer<QMirClientScreenObserver> mScreenObserver;
+    QScopedPointer<QMirClientAppStateController> mAppStateController;
     qreal mScaleFactor;
 
     MirConnection *mMirConnection;
@@ -104,4 +128,4 @@
     EGLNativeDisplayType mEglNativeDisplay;
 };
 
-#endif // UBUNTU_CLIENT_INTEGRATION_H
+#endif // QMIRCLIENTINTEGRATION_H

=== renamed file 'src/ubuntumirclient/logging.h' => 'src/ubuntumirclient/qmirclientlogging.h'
--- src/ubuntumirclient/logging.h	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientlogging.h	2017-02-21 12:29:19 +0000
@@ -1,31 +1,55 @@
-/*
- * 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
- * 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 QUBUNTULOGGING_H
-#define QUBUNTULOGGING_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTLOGGING_H
+#define QMIRCLIENTLOGGING_H
 
 #include <QLoggingCategory>
 
 #define ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop())
 
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclient)
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientBufferSwap)
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientInput)
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientGraphics)
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientCursor)
-Q_DECLARE_LOGGING_CATEGORY(ubuntumirclientDebug)
+Q_DECLARE_LOGGING_CATEGORY(mirclient)
+Q_DECLARE_LOGGING_CATEGORY(mirclientBufferSwap)
+Q_DECLARE_LOGGING_CATEGORY(mirclientInput)
+Q_DECLARE_LOGGING_CATEGORY(mirclientGraphics)
+Q_DECLARE_LOGGING_CATEGORY(mirclientCursor)
+Q_DECLARE_LOGGING_CATEGORY(mirclientDebug)
 
-#endif  // QUBUNTULOGGING_H
+#endif  // QMIRCLIENTLOGGING_H

=== renamed file 'src/ubuntumirclient/nativeinterface.cpp' => 'src/ubuntumirclient/qmirclientnativeinterface.cpp'
--- src/ubuntumirclient/nativeinterface.cpp	2016-08-23 17:03:35 +0000
+++ src/ubuntumirclient/qmirclientnativeinterface.cpp	2017-02-21 12:29:19 +0000
@@ -1,63 +1,87 @@
-/*
- * 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
- * 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/>.
- */
+/****************************************************************************
+**
+** Copyright (C) 2016-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
 
 // Local
-#include "nativeinterface.h"
-#include "screen.h"
-#include "glcontext.h"
-#include "window.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientglcontext.h"
+#include "qmirclientwindow.h"
 
 // Qt
-#include <private/qguiapplication_p.h>
+#include <QtGui/private/qguiapplication_p.h>
 #include <QtGui/qopenglcontext.h>
 #include <QtGui/qscreen.h>
 #include <QtCore/QMap>
 
-class UbuntuResourceMap : public QMap<QByteArray, UbuntuNativeInterface::ResourceType>
+class UbuntuResourceMap : public QMap<QByteArray, QMirClientNativeInterface::ResourceType>
 {
 public:
     UbuntuResourceMap()
-        : QMap<QByteArray, UbuntuNativeInterface::ResourceType>() {
-        insert("egldisplay", UbuntuNativeInterface::EglDisplay);
-        insert("eglcontext", UbuntuNativeInterface::EglContext);
-        insert("nativeorientation", UbuntuNativeInterface::NativeOrientation);
-        insert("display", UbuntuNativeInterface::Display);
-        insert("mirconnection", UbuntuNativeInterface::MirConnection);
-        insert("mirsurface", UbuntuNativeInterface::MirSurface);
-        insert("scale", UbuntuNativeInterface::Scale);
-        insert("formfactor", UbuntuNativeInterface::FormFactor);
+        : QMap<QByteArray, QMirClientNativeInterface::ResourceType>() {
+        insert("egldisplay", QMirClientNativeInterface::EglDisplay);
+        insert("eglcontext", QMirClientNativeInterface::EglContext);
+        insert("nativeorientation", QMirClientNativeInterface::NativeOrientation);
+        insert("display", QMirClientNativeInterface::Display);
+        insert("mirconnection", QMirClientNativeInterface::MirConnection);
+        insert("mirwindow", QMirClientNativeInterface::MirWindow);
+        insert("scale", QMirClientNativeInterface::Scale);
+        insert("formfactor", QMirClientNativeInterface::FormFactor);
     }
 };
 
 Q_GLOBAL_STATIC(UbuntuResourceMap, ubuntuResourceMap)
 
-UbuntuNativeInterface::UbuntuNativeInterface(const UbuntuClientIntegration *integration)
+QMirClientNativeInterface::QMirClientNativeInterface(const QMirClientClientIntegration *integration)
     : mIntegration(integration)
     , mGenericEventFilterType(QByteArrayLiteral("Event"))
     , mNativeOrientation(nullptr)
 {
 }
 
-UbuntuNativeInterface::~UbuntuNativeInterface()
+QMirClientNativeInterface::~QMirClientNativeInterface()
 {
     delete mNativeOrientation;
     mNativeOrientation = nullptr;
 }
 
-void* UbuntuNativeInterface::nativeResourceForIntegration(const QByteArray &resourceString)
+void* QMirClientNativeInterface::nativeResourceForIntegration(const QByteArray &resourceString)
 {
     const QByteArray lowerCaseResource = resourceString.toLower();
 
@@ -67,14 +91,14 @@
 
     const ResourceType resourceType = ubuntuResourceMap()->value(lowerCaseResource);
 
-    if (resourceType == UbuntuNativeInterface::MirConnection) {
+    if (resourceType == QMirClientNativeInterface::MirConnection) {
         return mIntegration->mirConnection();
     } else {
         return nullptr;
     }
 }
 
-void* UbuntuNativeInterface::nativeResourceForContext(
+void* QMirClientNativeInterface::nativeResourceForContext(
     const QByteArray& resourceString, QOpenGLContext* context)
 {
     if (!context)
@@ -87,13 +111,13 @@
 
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
 
-    if (kResourceType == UbuntuNativeInterface::EglContext)
-        return static_cast<UbuntuOpenGLContext*>(context->handle())->eglContext();
+    if (kResourceType == QMirClientNativeInterface::EglContext)
+        return static_cast<QMirClientOpenGLContext*>(context->handle())->eglContext();
     else
         return nullptr;
 }
 
-void* UbuntuNativeInterface::nativeResourceForWindow(const QByteArray& resourceString, QWindow* window)
+void* QMirClientNativeInterface::nativeResourceForWindow(const QByteArray& resourceString, QWindow* window)
 {
     const QByteArray kLowerCaseResource = resourceString.toLower();
     if (!ubuntuResourceMap()->contains(kLowerCaseResource))
@@ -106,18 +130,18 @@
     case NativeOrientation:
         // Return the device's native screen orientation.
         if (window) {
-            UbuntuScreen *ubuntuScreen = static_cast<UbuntuScreen*>(window->screen()->handle());
+            QMirClientScreen *ubuntuScreen = static_cast<QMirClientScreen*>(window->screen()->handle());
             mNativeOrientation = new Qt::ScreenOrientation(ubuntuScreen->nativeOrientation());
         } else {
             QPlatformScreen *platformScreen = QGuiApplication::primaryScreen()->handle();
             mNativeOrientation = new Qt::ScreenOrientation(platformScreen->nativeOrientation());
         }
         return mNativeOrientation;
-    case MirSurface:
+    case MirWindow:
         if (window) {
-            auto ubuntuWindow = static_cast<UbuntuWindow*>(window->handle());
+            auto ubuntuWindow = static_cast<QMirClientWindow*>(window->handle());
             if (ubuntuWindow) {
-                return ubuntuWindow->mirSurface();
+                return ubuntuWindow->mirWindow();
             } else {
                 return nullptr;
             }
@@ -129,7 +153,7 @@
     }
 }
 
-void* UbuntuNativeInterface::nativeResourceForScreen(const QByteArray& resourceString, QScreen* screen)
+void* QMirClientNativeInterface::nativeResourceForScreen(const QByteArray& resourceString, QScreen* screen)
 {
     const QByteArray kLowerCaseResource = resourceString.toLower();
     if (!ubuntuResourceMap()->contains(kLowerCaseResource))
@@ -137,28 +161,28 @@
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
     if (!screen)
         screen = QGuiApplication::primaryScreen();
-    auto ubuntuScreen = static_cast<UbuntuScreen*>(screen->handle());
-    if (kResourceType == UbuntuNativeInterface::Display) {
+    auto ubuntuScreen = static_cast<QMirClientScreen*>(screen->handle());
+    if (kResourceType == QMirClientNativeInterface::Display) {
         return mIntegration->eglNativeDisplay();
-    // Changes to the following properties are emitted via the UbuntuNativeInterface::screenPropertyChanged
-    // signal fired by UbuntuScreen. Connect to this signal for these properties updates.
+    // Changes to the following properties are emitted via the QMirClientNativeInterface::screenPropertyChanged
+    // signal fired by QMirClientScreen. Connect to this signal for these properties updates.
     // WARNING: code highly thread unsafe!
-    } else if (kResourceType == UbuntuNativeInterface::Scale) {
+    } else if (kResourceType == QMirClientNativeInterface::Scale) {
         // In application code, read with:
         //    float scale = *reinterpret_cast<float*>(nativeResourceForScreen("scale", screen()));
         return &ubuntuScreen->mScale;
-    } else if (kResourceType == UbuntuNativeInterface::FormFactor) {
+    } else if (kResourceType == QMirClientNativeInterface::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
+// Changes to these properties are emitted via the QMirClientNativeInterface::windowPropertyChanged
+// signal fired by QMirClientWindow. Connect to this signal for these properties updates.
+QVariantMap QMirClientNativeInterface::windowProperties(QPlatformWindow *window) const
 {
     QVariantMap propertyMap;
-    auto w = static_cast<UbuntuWindow*>(window);
+    auto w = static_cast<QMirClientWindow*>(window);
     if (w) {
         propertyMap.insert("scale", w->scale());
         propertyMap.insert("formFactor", w->formFactor());
@@ -167,9 +191,9 @@
     return propertyMap;
 }
 
-QVariant UbuntuNativeInterface::windowProperty(QPlatformWindow *window, const QString &name) const
+QVariant QMirClientNativeInterface::windowProperty(QPlatformWindow *window, const QString &name) const
 {
-    auto w = static_cast<UbuntuWindow*>(window);
+    auto w = static_cast<QMirClientWindow*>(window);
     if (!w) {
         return QVariant();
     }
@@ -185,7 +209,7 @@
     }
 }
 
-QVariant UbuntuNativeInterface::windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const
+QVariant QMirClientNativeInterface::windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const
 {
     QVariant returnVal = windowProperty(window, name);
     if (!returnVal.isValid()) {

=== renamed file 'src/ubuntumirclient/nativeinterface.h' => 'src/ubuntumirclient/qmirclientnativeinterface.h'
--- src/ubuntumirclient/nativeinterface.h	2016-06-21 12:17:55 +0000
+++ src/ubuntumirclient/qmirclientnativeinterface.h	2017-02-21 12:29:19 +0000
@@ -1,35 +1,59 @@
-/*
- * 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
- * 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_NATIVE_INTERFACE_H
-#define UBUNTU_NATIVE_INTERFACE_H
+/****************************************************************************
+**
+** Copyright (C) 2016-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTNATIVEINTERFACE_H
+#define QMIRCLIENTNATIVEINTERFACE_H
 
 #include <qpa/qplatformnativeinterface.h>
 
-#include "integration.h"
+#include "qmirclientintegration.h"
 
 class QPlatformScreen;
 
-class UbuntuNativeInterface : public QPlatformNativeInterface {
+class QMirClientNativeInterface : public QPlatformNativeInterface {
     Q_OBJECT
 public:
-    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection, MirSurface, Scale, FormFactor };
+    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection, MirWindow, Scale, FormFactor };
 
-    UbuntuNativeInterface(const UbuntuClientIntegration *integration);
-    ~UbuntuNativeInterface();
+    QMirClientNativeInterface(const QMirClientClientIntegration *integration);
+    ~QMirClientNativeInterface();
 
     // QPlatformNativeInterface methods.
     void* nativeResourceForIntegration(const QByteArray &resource) override;
@@ -51,9 +75,9 @@
     void screenPropertyChanged(QPlatformScreen *screen, const QString &propertyName);
 
 private:
-    const UbuntuClientIntegration *mIntegration;
+    const QMirClientClientIntegration *mIntegration;
     const QByteArray mGenericEventFilterType;
     Qt::ScreenOrientation* mNativeOrientation;
 };
 
-#endif // UBUNTU_NATIVE_INTERFACE_H
+#endif // QMIRCLIENTNATIVEINTERFACE_H

=== renamed file 'src/ubuntumirclient/orientationchangeevent_p.h' => 'src/ubuntumirclient/qmirclientorientationchangeevent_p.h'
--- src/ubuntumirclient/orientationchangeevent_p.h	2015-08-06 14:14:39 +0000
+++ src/ubuntumirclient/qmirclientorientationchangeevent_p.h	2017-02-21 12:29:19 +0000
@@ -1,24 +1,48 @@
-/*
- * Copyright (C) 2014 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 ORIENTATIONCHANGEEVENT_P_H
-#define ORIENTATIONCHANGEEVENT_P_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTORIENTATIONCHANGEEVENT_P_H
+#define QMIRCLIENTORIENTATIONCHANGEEVENT_P_H
 
 #include <QEvent>
-#include "logging.h"
+#include "qmirclientlogging.h"
 
 class OrientationChangeEvent : public QEvent {
 public:
@@ -34,4 +58,4 @@
     Orientation mOrientation;
 };
 
-#endif // ORIENTATIONCHANGEEVENT_P_H
+#endif // QMIRCLIENTORIENTATIONCHANGEEVENT_P_H

=== renamed file 'src/ubuntumirclient/platformservices.cpp' => 'src/ubuntumirclient/qmirclientplatformservices.cpp'
--- src/ubuntumirclient/platformservices.cpp	2014-06-18 23:10:00 +0000
+++ src/ubuntumirclient/qmirclientplatformservices.cpp	2017-02-21 12:29:19 +0000
@@ -1,37 +1,61 @@
-/*
- * Copyright (C) 2014 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 "platformservices.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientplatformservices.h"
 
 #include <QUrl>
 
 #include <ubuntu/application/url_dispatcher/service.h>
 #include <ubuntu/application/url_dispatcher/session.h>
 
-bool UbuntuPlatformServices::openUrl(const QUrl &url)
-{
-    return callDispatcher(url);
-}
-
-bool UbuntuPlatformServices::openDocument(const QUrl &url)
-{
-    return callDispatcher(url);
-}
-
-bool UbuntuPlatformServices::callDispatcher(const QUrl &url)
+bool QMirClientPlatformServices::openUrl(const QUrl &url)
+{
+    return callDispatcher(url);
+}
+
+bool QMirClientPlatformServices::openDocument(const QUrl &url)
+{
+    return callDispatcher(url);
+}
+
+bool QMirClientPlatformServices::callDispatcher(const QUrl &url)
 {
     UAUrlDispatcherSession* session = ua_url_dispatcher_session();
     if (!session)

=== renamed file 'src/ubuntumirclient/platformservices.h' => 'src/ubuntumirclient/qmirclientplatformservices.h'
--- src/ubuntumirclient/platformservices.h	2014-06-18 23:10:00 +0000
+++ src/ubuntumirclient/qmirclientplatformservices.h	2017-02-21 12:29:19 +0000
@@ -1,27 +1,51 @@
-/*
- * Copyright (C) 2014 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_PLATFORM_SERVICES_H
-#define UBUNTU_PLATFORM_SERVICES_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTPLATFORMSERVICES_H
+#define QMIRCLIENTPLATFORMSERVICES_H
 
 #include <qpa/qplatformservices.h>
 #include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>
 #include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>
 
-class UbuntuPlatformServices : public QPlatformServices {
+class QMirClientPlatformServices : public QPlatformServices {
 public:
     bool openUrl(const QUrl &url) override;
     bool openDocument(const QUrl &url) override;
@@ -30,4 +54,4 @@
     bool callDispatcher(const QUrl &url);
 };
 
-#endif // UBUNTU_PLATFORM_SERVICES_H
+#endif // QMIRCLIENTPLATFORMSERVICES_H

=== renamed file 'src/ubuntumirclient/plugin.cpp' => 'src/ubuntumirclient/qmirclientplugin.cpp'
--- src/ubuntumirclient/plugin.cpp	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientplugin.cpp	2017-02-21 12:29:19 +0000
@@ -1,39 +1,60 @@
-/*
- * 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
- * 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 "plugin.h"
-#include "integration.h"
-#include "logging.h"
-#include "qpa/qplatformwindow.h"
-
-Q_LOGGING_CATEGORY(ubuntumirclient, "ubuntumirclient", QtWarningMsg)
-
-QPlatformIntegration *UbuntuMirClientIntegrationPlugin::create(const QString &system,
-                                                               const QStringList &/*paramList*/,
-                                                               int &argc, char **argv)
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientplugin.h"
+#include "qmirclientintegration.h"
+#include "qmirclientlogging.h"
+
+Q_LOGGING_CATEGORY(mirclient, "qt.qpa.mirclient", QtWarningMsg)
+
+QPlatformIntegration *QMirClientIntegrationPlugin::create(const QString &system,
+                                                          const QStringList &/*paramList*/,
+                                                          int &argc, char **argv)
 {
-    qRegisterMetaType<QPlatformWindow*>("QPlatformWindow*");
-
     if (system.toLower() == QLatin1String("ubuntumirclient")) {
 #ifdef PLATFORM_API_TOUCH
         setenv("UBUNTU_PLATFORM_API_BACKEND", "touch_mirclient", 1);
 #else
         setenv("UBUNTU_PLATFORM_API_BACKEND", "desktop_mirclient", 1);
 #endif
-        return new UbuntuClientIntegration(argc, argv);
+        return new QMirClientClientIntegration(argc, argv);
     } else {
         return 0;
     }

=== renamed file 'src/ubuntumirclient/plugin.h' => 'src/ubuntumirclient/qmirclientplugin.h'
--- src/ubuntumirclient/plugin.h	2016-06-24 12:36:24 +0000
+++ src/ubuntumirclient/qmirclientplugin.h	2017-02-21 12:29:19 +0000
@@ -1,31 +1,56 @@
-/*
- * 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
- * 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_CLIENT_PLUGIN_H
-#define UBUNTU_CLIENT_PLUGIN_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTPLUGIN_H
+#define QMIRCLIENTPLUGIN_H
 
 #include <qpa/qplatformintegrationplugin.h>
 
-class UbuntuMirClientIntegrationPlugin : public QPlatformIntegrationPlugin
+class QMirClientIntegrationPlugin : public QPlatformIntegrationPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID QPlatformIntegrationFactoryInterface_iid FILE "ubuntumirclient.json")
 
 public:
-    QPlatformIntegration *create(const QString &system, const QStringList &paramList, int &argc, char **argv) override;
+    QPlatformIntegration *create(const QString &system, const QStringList &paramList,
+                                 int &argc, char **argv) override;
 };
 
-#endif // UBUNTU_CLIENT_PLUGIN_H
+#endif // QMIRCLIENTPLUGIN_H

=== renamed file 'src/ubuntumirclient/screen.cpp' => 'src/ubuntumirclient/qmirclientscreen.cpp'
--- src/ubuntumirclient/screen.cpp	2016-09-14 14:43:12 +0000
+++ src/ubuntumirclient/qmirclientscreen.cpp	2017-02-21 12:29:19 +0000
@@ -1,24 +1,48 @@
-/*
- * 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
- * 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/>.
- */
+/****************************************************************************
+**
+** Copyright (C) 2014-2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
 
 // local
-#include "screen.h"
-#include "logging.h"
-#include "orientationchangeevent_p.h"
-#include "nativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientlogging.h"
+#include "qmirclientorientationchangeevent_p.h"
+#include "qmirclientnativeinterface.h"
 
 #include <mir_toolkit/mir_client_library.h>
 
@@ -54,7 +78,7 @@
         static_cast<QEvent::Type>(QEvent::registerEventType());
 
 
-UbuntuScreen::UbuntuScreen(const MirOutput *output, MirConnection *connection)
+QMirClientScreen::QMirClientScreen(const MirOutput *output, MirConnection *connection)
     : mDevicePixelRatio(1.0)
     , mFormat(QImage::Format_RGB32)
     , mDepth(32)
@@ -67,11 +91,11 @@
     setMirOutput(output);
 }
 
-UbuntuScreen::~UbuntuScreen()
+QMirClientScreen::~QMirClientScreen()
 {
 }
 
-void UbuntuScreen::customEvent(QEvent* event) {
+void QMirClientScreen::customEvent(QEvent* event) {
     Q_ASSERT(QThread::currentThread() == thread());
 
     OrientationChangeEvent* oReadingEvent = static_cast<OrientationChangeEvent*>(event);
@@ -99,11 +123,11 @@
     }
 
     // Raise the event signal so that client apps know the orientation changed
-    qCDebug(ubuntumirclient, "UbuntuScreen::customEvent - handling orientation change to %s", orientationToStr(mCurrentOrientation));
+    qCDebug(mirclient, "QMirClientScreen::customEvent - handling orientation change to %s", orientationToStr(mCurrentOrientation));
     QWindowSystemInterface::handleScreenOrientationChange(screen(), mCurrentOrientation);
 }
 
-void UbuntuScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
+void QMirClientScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
 {
     if ((windowWidth > windowHeight && mGeometry.width() < mGeometry.height())
      || (windowWidth < windowHeight && mGeometry.width() > mGeometry.height())) {
@@ -120,7 +144,7 @@
         mGeometry.setWidth(currGeometry.height());
         mGeometry.setHeight(currGeometry.width());
 
-        qCDebug(ubuntumirclient, "UbuntuScreen::handleWindowSurfaceResize - new screen geometry (w=%d, h=%d)",
+        qCDebug(mirclient, "QMirClientScreen::handleWindowSurfaceResize - new screen geometry (w=%d, h=%d)",
             mGeometry.width(), mGeometry.height());
         QWindowSystemInterface::handleScreenGeometryChange(screen(),
                                                            mGeometry /* newGeometry */,
@@ -131,12 +155,12 @@
         } else {
             mCurrentOrientation = Qt::LandscapeOrientation;
         }
-        qCDebug(ubuntumirclient, "UbuntuScreen::handleWindowSurfaceResize - new orientation %s",orientationToStr(mCurrentOrientation));
+        qCDebug(mirclient, "QMirClientScreen::handleWindowSurfaceResize - new orientation %s",orientationToStr(mCurrentOrientation));
         QWindowSystemInterface::handleScreenOrientationChange(screen(), mCurrentOrientation);
     }
 }
 
-void UbuntuScreen::setMirOutput(const MirOutput *output)
+void QMirClientScreen::setMirOutput(const MirOutput *output)
 {
     // Physical screen size (in mm)
     mPhysicalSize.setWidth(mir_output_get_physical_width_mm(output));
@@ -181,7 +205,7 @@
     mCurrentOrientation = (mNativeOrientation == Qt::LandscapeOrientation) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
 }
 
-void UbuntuScreen::updateMirOutput(const MirOutput *output)
+void QMirClientScreen::updateMirOutput(const MirOutput *output)
 {
     auto oldRefreshRate = mRefreshRate;
     auto oldScale = mScale;
@@ -201,7 +225,7 @@
         QWindowSystemInterface::handleScreenRefreshRateChange(screen(), mRefreshRate);
     }
 
-    auto nativeInterface = static_cast<UbuntuNativeInterface *>(qGuiApp->platformNativeInterface());
+    auto nativeInterface = static_cast<QMirClientNativeInterface *>(qGuiApp->platformNativeInterface());
     if (!qFuzzyCompare(mScale, oldScale)) {
         nativeInterface->screenPropertyChanged(this, QStringLiteral("scale"));
     }
@@ -210,14 +234,14 @@
     }
 }
 
-void UbuntuScreen::setAdditionalMirDisplayProperties(float scale, MirFormFactor formFactor, int dpi)
+void QMirClientScreen::setAdditionalMirDisplayProperties(float scale, MirFormFactor formFactor, int dpi)
 {
     if (mDpi != dpi) {
         mDpi = dpi;
         QWindowSystemInterface::handleScreenLogicalDotsPerInchChange(screen(), dpi, dpi);
     }
 
-    auto nativeInterface = static_cast<UbuntuNativeInterface *>(qGuiApp->platformNativeInterface());
+    auto nativeInterface = static_cast<QMirClientNativeInterface *>(qGuiApp->platformNativeInterface());
     if (!qFuzzyCompare(mScale, scale)) {
         mScale = scale;
         nativeInterface->screenPropertyChanged(this, QStringLiteral("scale"));
@@ -228,7 +252,7 @@
     }
 }
 
-QDpi UbuntuScreen::logicalDpi() const
+QDpi QMirClientScreen::logicalDpi() const
 {
     if (mDpi > 0) {
         return QDpi(mDpi, mDpi);

=== renamed file 'src/ubuntumirclient/screen.h' => 'src/ubuntumirclient/qmirclientscreen.h'
--- src/ubuntumirclient/screen.h	2016-12-19 10:16:55 +0000
+++ src/ubuntumirclient/qmirclientscreen.h	2017-02-21 12:29:19 +0000
@@ -1,38 +1,62 @@
-/*
- * 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
- * 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_H
-#define UBUNTU_SCREEN_H
+/****************************************************************************
+**
+** Copyright (C) 2014-2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTSCREEN_H
+#define QMIRCLIENTSCREEN_H
 
 #include <qpa/qplatformscreen.h>
 #include <QSurfaceFormat>
 
 #include <mir_toolkit/common.h> // just for MirFormFactor enum
 
-#include "cursor.h"
+#include "qmirclientcursor.h"
 
 struct MirConnection;
 struct MirOutput;
 
-class UbuntuScreen : public QObject, public QPlatformScreen
+class QMirClientScreen : public QObject, public QPlatformScreen
 {
     Q_OBJECT
 public:
-    UbuntuScreen(const MirOutput *output, MirConnection *connection);
-    virtual ~UbuntuScreen();
+    QMirClientScreen(const MirOutput *output, MirConnection *connection);
+    virtual ~QMirClientScreen();
 
     // QPlatformScreen methods.
     QImage::Format format() const override { return mFormat; }
@@ -44,7 +68,7 @@
     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); }
+    QPlatformCursor *cursor() const override { return const_cast<QMirClientCursor*>(&mCursor); }
 
     // Additional Screen properties from Mir
     int mirOutputId() const { return mOutputId; }
@@ -74,9 +98,9 @@
     MirFormFactor mFormFactor;
     float mScale;
     int mOutputId;
-    UbuntuCursor mCursor;
+    QMirClientCursor mCursor;
 
-    friend class UbuntuNativeInterface;
+    friend class QMirClientNativeInterface;
 };
 
-#endif // UBUNTU_SCREEN_H
+#endif // QMIRCLIENTSCREEN_H

=== renamed file 'src/ubuntumirclient/screenobserver.cpp' => 'src/ubuntumirclient/qmirclientscreenobserver.cpp'
--- src/ubuntumirclient/screenobserver.cpp	2016-09-14 14:43:12 +0000
+++ src/ubuntumirclient/qmirclientscreenobserver.cpp	2017-02-21 12:29:19 +0000
@@ -1,23 +1,47 @@
-/*
- * 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 "screenobserver.h"
-#include "screen.h"
-#include "window.h"
-#include "logging.h"
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qmirclientscreenobserver.h"
+#include "qmirclientscreen.h"
+#include "qmirclientwindow.h"
+#include "qmirclientlogging.h"
 
 // Qt
 #include <QMetaObject>
@@ -33,7 +57,7 @@
     static void displayConfigurationChangedCallback(MirConnection */*connection*/, void* context)
     {
         ASSERT(context != NULL);
-        UbuntuScreenObserver *observer = static_cast<UbuntuScreenObserver *>(context);
+        QMirClientScreenObserver *observer = static_cast<QMirClientScreenObserver *>(context);
         QMetaObject::invokeMethod(observer, "update");
     }
 
@@ -51,14 +75,14 @@
     }
 } // anonymous namespace
 
-UbuntuScreenObserver::UbuntuScreenObserver(MirConnection *mirConnection)
+QMirClientScreenObserver::QMirClientScreenObserver(MirConnection *mirConnection)
     : mMirConnection(mirConnection)
 {
     mir_connection_set_display_config_change_callback(mirConnection, ::displayConfigurationChangedCallback, this);
     update();
 }
 
-void UbuntuScreenObserver::update()
+void QMirClientScreenObserver::update()
 {
     // Wrap MirDisplayConfiguration to always delete when out of scope
     auto configDeleter = [](MirDisplayConfig *config) { mir_display_config_release(config); };
@@ -66,22 +90,22 @@
     configUp displayConfig(mir_connection_create_display_configuration(mMirConnection), configDeleter);
 
     // Mir only tells us something changed, it is up to us to figure out what.
-    QList<UbuntuScreen*> newScreenList;
-    QList<UbuntuScreen*> oldScreenList = mScreenList;
+    QList<QMirClientScreen*> newScreenList;
+    QList<QMirClientScreen*> oldScreenList = mScreenList;
     mScreenList.clear();
 
     for (int i = 0; i < mir_display_config_get_num_outputs(displayConfig.get()); i++) {
         const MirOutput *output = mir_display_config_get_output(displayConfig.get(), i);
         if (mir_output_is_enabled(output)) {
-            UbuntuScreen *screen = findScreenWithId(oldScreenList, mir_output_get_id(output));
+            QMirClientScreen *screen = findScreenWithId(oldScreenList, mir_output_get_id(output));
             if (screen) { // we've already set up this display before
                 screen->updateMirOutput(output);
                 oldScreenList.removeAll(screen);
             } else {
-                // new display, so create UbuntuScreen for it
-                screen = new UbuntuScreen(output, mMirConnection);
+                // new display, so create QMirClientScreen for it
+                screen = new QMirClientScreen(output, mMirConnection);
                 newScreenList.append(screen);
-                qCDebug(ubuntumirclient) << "Added Screen with id" << mir_output_get_id(output)
+                qCDebug(mirclient) << "Added Screen with id" << mir_output_get_id(output)
                                          << "and geometry" << screen->geometry();
             }
             mScreenList.append(screen);
@@ -104,22 +128,22 @@
         Q_EMIT screenAdded(screen);
     }
 
-    qCDebug(ubuntumirclient) << "=======================================";
+    qCDebug(mirclient) << "=======================================";
     for (auto screen: mScreenList) {
-        qCDebug(ubuntumirclient) << screen << "- id:" << screen->mirOutputId()
+        qCDebug(mirclient) << screen << "- id:" << screen->mirOutputId()
                                  << "geometry:" << screen->geometry()
                                  << "form factor:" << mirFormFactorToStr(screen->formFactor())
                                  << "scale:" << screen->scale();
     }
-    qCDebug(ubuntumirclient) << "=======================================";
+    qCDebug(mirclient) << "=======================================";
 }
 
-UbuntuScreen *UbuntuScreenObserver::findScreenWithId(int id)
+QMirClientScreen *QMirClientScreenObserver::findScreenWithId(int id)
 {
     return findScreenWithId(mScreenList, id);
 }
 
-UbuntuScreen *UbuntuScreenObserver::findScreenWithId(const QList<UbuntuScreen *> &list, int id)
+QMirClientScreen *QMirClientScreenObserver::findScreenWithId(const QList<QMirClientScreen *> &list, int id)
 {
     Q_FOREACH (const auto screen, list) {
         if (screen->mirOutputId() == id) {
@@ -129,7 +153,7 @@
     return nullptr;
 }
 
-void UbuntuScreenObserver::handleScreenPropertiesChange(UbuntuScreen *screen, int dpi,
+void QMirClientScreenObserver::handleScreenPropertiesChange(QMirClientScreen *screen, int dpi,
                                                         MirFormFactor formFactor, float scale)
 {
     screen->setAdditionalMirDisplayProperties(scale, formFactor, dpi);

=== renamed file 'src/ubuntumirclient/screenobserver.h' => 'src/ubuntumirclient/qmirclientscreenobserver.h'
--- src/ubuntumirclient/screenobserver.h	2016-04-25 09:39:59 +0000
+++ src/ubuntumirclient/qmirclientscreenobserver.h	2017-02-21 12:29:19 +0000
@@ -1,54 +1,78 @@
-/*
- * 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_SCREEN_OBSERVER_H
-#define UBUNTU_SCREEN_OBSERVER_H
+/****************************************************************************
+**
+** Copyright (C) 2016 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QMIRCLIENTSCREENOBSERVER_H
+#define QMIRCLIENTSCREENOBSERVER_H
 
 #include <QObject>
 
 #include <mir_toolkit/mir_connection.h>
 
-class UbuntuScreen;
+class QMirClientScreen;
 
-class UbuntuScreenObserver : public QObject
+class QMirClientScreenObserver : public QObject
 {
     Q_OBJECT
 
 public:
-    UbuntuScreenObserver(MirConnection *connection);
-
-    QList<UbuntuScreen*> screens() const { return mScreenList; }
-    UbuntuScreen *findScreenWithId(int id);
-
-    void handleScreenPropertiesChange(UbuntuScreen *screen, int dpi,
+    QMirClientScreenObserver(MirConnection *connection);
+
+    QList<QMirClientScreen*> screens() const { return mScreenList; }
+    QMirClientScreen *findScreenWithId(int id);
+
+    void handleScreenPropertiesChange(QMirClientScreen *screen, int dpi,
                                       MirFormFactor formFactor, float scale);
 
 Q_SIGNALS:
-    void screenAdded(UbuntuScreen *screen);
-    void screenRemoved(UbuntuScreen *screen);
+    void screenAdded(QMirClientScreen *screen);
+    void screenRemoved(QMirClientScreen *screen);
 
 private Q_SLOTS:
     void update();
 
 private:
-    UbuntuScreen *findScreenWithId(const QList<UbuntuScreen *> &list, int id);
-    void removeScreen(UbuntuScreen *screen);
+    QMirClientScreen *findScreenWithId(const QList<QMirClientScreen *> &list, int id);
+    void removeScreen(QMirClientScreen *screen);
 
     MirConnection *mMirConnection;
-    QList<UbuntuScreen*> mScreenList;
+    QList<QMirClientScreen*> mScreenList;
 };
 
-#endif // UBUNTU_SCREEN_OBSERVER_H
+#endif // QMIRCLIENTSCREENOBSERVER_H

=== renamed file 'src/ubuntumirclient/window.cpp' => 'src/ubuntumirclient/qmirclientwindow.cpp'
--- src/ubuntumirclient/window.cpp	2017-01-19 18:27:29 +0000
+++ src/ubuntumirclient/qmirclientwindow.cpp	2017-02-21 12:29:19 +0000
@@ -1,27 +1,51 @@
-/*
- * Copyright (C) 2014-2017 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/>.
- */
+/****************************************************************************
+**
+** Copyright (C) 2014-2017 Canonical, Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
 
 // Local
-#include "window.h"
-#include "debugextension.h"
-#include "nativeinterface.h"
-#include "input.h"
-#include "integration.h"
-#include "screen.h"
-#include "logging.h"
+#include "qmirclientwindow.h"
+#include "qmirclientdebugextension.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientinput.h"
+#include "qmirclientintegration.h"
+#include "qmirclientscreen.h"
+#include "qmirclientlogging.h"
 
 #include <mir_toolkit/mir_client_library.h>
 #include <mir_toolkit/version.h>
@@ -31,21 +55,20 @@
 #include <QMutexLocker>
 #include <QSize>
 #include <QtMath>
-#include <private/qeglconvenience_p.h>
-#include <private/qguiapplication_p.h>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
 
 // Platform API
 #include <ubuntu/application/instance.h>
 
 #include <EGL/egl.h>
 
-Q_LOGGING_CATEGORY(ubuntumirclientBufferSwap, "ubuntumirclient.bufferSwap", QtWarningMsg)
+Q_LOGGING_CATEGORY(mirclientBufferSwap, "qt.qpa.mirclient.bufferSwap", QtWarningMsg)
 
+namespace
+{
 const Qt::WindowType LowChromeWindowHint = (Qt::WindowType)0x00800000;
 
-namespace
-{
-
 // FIXME: this used to be defined by platform-api, but it's been removed in v3. Change ubuntu-keyboard to use
 // a different enum for window roles.
 enum UAUiWindowRole {
@@ -61,14 +84,14 @@
 
 struct MirSpecDeleter
 {
-    void operator()(MirSurfaceSpec *spec) { mir_surface_spec_release(spec); }
+    void operator()(MirWindowSpec *spec) { mir_window_spec_release(spec); }
 };
 
-using Spec = std::unique_ptr<MirSurfaceSpec, MirSpecDeleter>;
+using Spec = std::unique_ptr<MirWindowSpec, MirSpecDeleter>;
 
-EGLNativeWindowType nativeWindowFor(MirSurface *surf)
+EGLNativeWindowType nativeWindowFor(MirWindow *surf)
 {
-    auto stream = mir_surface_get_buffer_stream(surf);
+    auto stream = mir_window_get_buffer_stream(surf);
     return reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(stream));
 }
 
@@ -89,18 +112,18 @@
     Q_UNREACHABLE();
 }
 
-const char *mirSurfaceStateToStr(MirSurfaceState surfaceState)
+const char *mirWindowStateToStr(MirWindowState windowState)
 {
-    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";
-    case mir_surface_states: Q_UNREACHABLE();
+    switch (windowState) {
+    case mir_window_state_unknown: return "unknown";
+    case mir_window_state_restored: return "restored";
+    case mir_window_state_minimized: return "minimized";
+    case mir_window_state_maximized: return "vertmaximized";
+    case mir_window_state_vertmaximized: return "vertmaximized";
+    case mir_window_state_fullscreen: return "fullscreen";
+    case mir_window_state_horizmaximized: return "horizmaximized";
+    case mir_window_state_hidden: return "hidden";
+    case mir_window_states: Q_UNREACHABLE();
     }
     Q_UNREACHABLE();
 }
@@ -123,57 +146,57 @@
     Q_UNREACHABLE();
 }
 
-const char *mirSurfaceTypeToStr(MirSurfaceType type)
+const char *mirWindowTypeToStr(MirWindowType 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();
+    case mir_window_type_normal:       return "Normal";        /**< AKA "regular"                   */
+    case mir_window_type_utility:      return "Utility";       /**< AKA "floating regular"          */
+    case mir_window_type_dialog:       return "Dialog";
+    case mir_window_type_gloss:        return "Gloss";
+    case mir_window_type_freestyle:    return "Freestyle";
+    case mir_window_type_menu:         return "Menu";
+    case mir_window_type_inputmethod:  return "Input Method";  /**< AKA "OSK" or handwriting etc.   */
+    case mir_window_type_satellite:    return "Satellite";     /**< AKA "toolbox"/"toolbar"         */
+    case mir_window_type_tip:          return "Tip";           /**< AKA "tooltip"                   */
+    case mir_window_types:             Q_UNREACHABLE();
     }
     return "";
 }
 
-MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
+MirWindowState qtWindowStateToMirWindowState(Qt::WindowState state)
 {
     switch (state) {
     case Qt::WindowNoState:
     case Qt::WindowActive:
-        return mir_surface_state_restored;
+        return mir_window_state_restored;
     case Qt::WindowFullScreen:
-        return mir_surface_state_fullscreen;
+        return mir_window_state_fullscreen;
     case Qt::WindowMaximized:
-        return mir_surface_state_maximized;
+        return mir_window_state_maximized;
     case Qt::WindowMinimized:
-        return mir_surface_state_minimized;
+        return mir_window_state_minimized;
     }
-    return mir_surface_state_unknown; // should never be reached
+    return mir_window_state_unknown; // should never be reached
 }
 
-MirSurfaceType qtWindowTypeToMirSurfaceType(Qt::WindowType type)
+MirWindowType qtWindowTypeToMirWindowType(Qt::WindowType type)
 {
     switch (type & Qt::WindowType_Mask) {
     case Qt::Dialog:
-        return mir_surface_type_dialog;
+        return mir_window_type_dialog;
     case Qt::Sheet:
     case Qt::Drawer:
-        return mir_surface_type_utility;
+        return mir_window_type_utility;
     case Qt::Popup:
     case Qt::Tool:
-        return mir_surface_type_menu;
+        return mir_window_type_menu;
     case Qt::ToolTip:
-        return mir_surface_type_tip;
+        return mir_window_type_tip;
     case Qt::SplashScreen:
-        return mir_surface_type_freestyle;
+        return mir_window_type_freestyle;
     case Qt::Window:
     default:
-        return mir_surface_type_normal;
+        return mir_window_type_normal;
     }
 }
 
@@ -196,21 +219,21 @@
     return static_cast<UAUiWindowRole>(role);
 }
 
-UbuntuWindow *transientParentFor(QWindow *window)
+QMirClientWindow *transientParentFor(QWindow *window)
 {
     QWindow *parent = window->transientParent();
-    return parent ? static_cast<UbuntuWindow *>(parent->handle()) : nullptr;
+    return parent ? static_cast<QMirClientWindow *>(parent->handle()) : nullptr;
 }
 
-bool requiresParent(const MirSurfaceType type)
+bool requiresParent(const MirWindowType type)
 {
     switch (type) {
-    case mir_surface_type_dialog: //FIXME - not quite what the specification dictates, but is what Mir's api dictates
-    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:
+    case mir_window_type_dialog: //FIXME - not quite what the specification dictates, but is what Mir's api dictates
+    case mir_window_type_utility:
+    case mir_window_type_gloss:
+    case mir_window_type_menu:
+    case mir_window_type_satellite:
+    case mir_window_type_tip:
         return true;
     default:
         return false;
@@ -219,25 +242,25 @@
 
 bool requiresParent(const Qt::WindowType type)
 {
-    return requiresParent(qtWindowTypeToMirSurfaceType(type));
+    return requiresParent(qtWindowTypeToMirWindowType(type));
 }
 
-Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, UbuntuWindow *parentWindowHandle,
+Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, QMirClientWindow *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());
+    auto type = qtWindowTypeToMirWindowType(window->type());
 
     if (U_ON_SCREEN_KEYBOARD_ROLE == roleFor(window)) {
-        type = mir_surface_type_inputmethod;
+        type = mir_window_type_inputmethod;
     }
 
     MirRectangle location{geometry.x(), geometry.y(), 0, 0};
-    MirSurface *parent = nullptr;
+    MirWindow *parent = nullptr;
     if (parentWindowHandle) {
-        parent = parentWindowHandle->mirSurface();
+        parent = parentWindowHandle->mirWindow();
         // Qt uses absolute positioning, but Mir positions surfaces relative to parent.
         location.top  -= parentWindowHandle->geometry().top();
         location.left -= parentWindowHandle->geometry().left();
@@ -246,91 +269,93 @@
     Spec spec;
 
     switch (type) {
-    case mir_surface_type_menu:
-        spec = Spec{mir_connection_create_spec_for_menu(connection, width, height, pixelFormat, parent,
+    case mir_window_type_menu:
+        spec = Spec{mir_create_menu_window_spec(connection, width, height, 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:
+    case mir_window_type_dialog:
+        spec = Spec{mir_create_modal_dialog_window_spec(connection, width, height, parent)};
+        break;
+    case mir_window_type_utility:
+        spec = Spec{mir_create_dialog_window_spec(connection, width, height)};
+        break;
+    case mir_window_type_tip:
 #if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 4, 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,
+        spec = Spec{mir_create_tip_window_spec(connection, width, height, 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)};
+    case mir_window_type_inputmethod:
+        spec = Spec{mir_create_input_method_window_spec(connection, width, height)};
         break;
     default:
-        spec = Spec{mir_connection_create_spec_for_normal_surface(connection, width, height, pixelFormat)};
+        spec = Spec{mir_create_normal_window_spec(connection, width, height)};
         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);
+    mir_window_spec_set_pixel_format(spec.get(), pixelFormat);
+
+    qCDebug(mirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
+            window, mirWindowTypeToStr(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)
+void setSizingConstraints(MirWindowSpec *spec, const QSize& minSize, const QSize& maxSize, const QSize& increment)
 {
-    mir_surface_spec_set_min_width(spec, minSize.width());
-    mir_surface_spec_set_min_height(spec, minSize.height());
+    mir_window_spec_set_min_width(spec, minSize.width());
+    mir_window_spec_set_min_height(spec, minSize.height());
     if (maxSize.width() >= minSize.width()) {
-        mir_surface_spec_set_max_width(spec, maxSize.width());
+        mir_window_spec_set_max_width(spec, maxSize.width());
     }
     if (maxSize.height() >= minSize.height()) {
-        mir_surface_spec_set_max_height(spec, maxSize.height());
+        mir_window_spec_set_max_height(spec, maxSize.height());
     }
     if (increment.width() > 0) {
-        mir_surface_spec_set_width_increment(spec, increment.width());
+        mir_window_spec_set_width_increment(spec, increment.width());
     }
     if (increment.height() > 0) {
-        mir_surface_spec_set_height_increment(spec, increment.height());
+        mir_window_spec_set_height_increment(spec, increment.height());
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuWindow *parentWindowHandle,
+MirWindow *createMirWindow(QWindow *window, int mirOutputId, QMirClientWindow *parentWindowHandle,
                              MirPixelFormat pixelFormat, MirConnection *connection,
-                             mir_surface_event_callback inputCallback, void *inputContext)
+                             MirWindowEventCallback inputCallback, void *inputContext)
 {
     auto spec = makeSurfaceSpec(window, pixelFormat, parentWindowHandle, connection);
 
     // Install event handler as early as possible
-    mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
+    mir_window_spec_set_event_handler(spec.get(), inputCallback, inputContext);
 
     const auto title = window->title().toUtf8();
-    mir_surface_spec_set_name(spec.get(), title.constData());
+    mir_window_spec_set_name(spec.get(), title.constData());
 
     setSizingConstraints(spec.get(), window->minimumSize(), window->maximumSize(), window->sizeIncrement());
 
     if (window->windowState() == Qt::WindowFullScreen) {
-        mir_surface_spec_set_fullscreen_on_output(spec.get(), mirOutputId);
+        mir_window_spec_set_fullscreen_on_output(spec.get(), mirOutputId);
     }
 
     if (window->flags() & LowChromeWindowHint) {
-        mir_surface_spec_set_shell_chrome(spec.get(), mir_shell_chrome_low);
+        mir_window_spec_set_shell_chrome(spec.get(), mir_shell_chrome_low);
     }
 
     if (!window->isVisible()) {
-        mir_surface_spec_set_state(spec.get(), mir_surface_state_hidden);
+        mir_window_spec_set_state(spec.get(), mir_window_state_hidden);
     }
 
-    auto surface = mir_surface_create_sync(spec.get());
-    Q_ASSERT(mir_surface_is_valid(surface));
+    auto surface = mir_create_window_sync(spec.get());
+    Q_ASSERT(mir_window_is_valid(surface));
     return surface;
 }
 
-UbuntuWindow *getParentIfNecessary(QWindow *window, UbuntuInput *input)
+QMirClientWindow *getParentIfNecessary(QWindow *window, QMirClientInput *input)
 {
-    UbuntuWindow *parentWindowHandle = nullptr;
+    QMirClientWindow *parentWindowHandle = nullptr;
     if (requiresParent(window->type())) {
         parentWindowHandle = transientParentFor(window);
         if (parentWindowHandle == nullptr) {
@@ -344,7 +369,7 @@
 
 MirPixelFormat disableAlphaBufferIfPossible(MirPixelFormat pixelFormat)
 {
-    switch(pixelFormat) {
+    switch (pixelFormat) {
     case mir_pixel_format_abgr_8888:
         return mir_pixel_format_xbgr_8888;
     case mir_pixel_format_argb_8888:
@@ -378,7 +403,7 @@
 class UbuntuSurface
 {
 public:
-    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection);
+    UbuntuSurface(QMirClientWindow *platformWindow, EGLDisplay display, QMirClientInput *input, MirConnection *connection);
     ~UbuntuSurface();
 
     UbuntuSurface(const UbuntuSurface &) = delete;
@@ -392,17 +417,17 @@
     void handleSurfaceResized(int width, int height);
     int needsRepaint() const;
 
-    MirSurfaceState state() const { return mir_surface_get_state(mMirSurface); }
-    void setState(MirSurfaceState state);
+    MirWindowState state() const { return mir_window_get_state(mMirWindow); }
+    void setState(MirWindowState state);
 
-    MirSurfaceType type() const { return mir_surface_get_type(mMirSurface); }
+    MirWindowType type() const { return mir_window_get_type(mMirWindow); }
 
     void setShellChrome(MirShellChrome shellChrome);
 
     EGLSurface eglSurface() const { return mEglSurface; }
-    MirSurface *mirSurface() const { return mMirSurface; }
+    MirWindow *mirWindow() const { return mMirWindow; }
 
-    void setSurfaceParent(MirSurface*);
+    void setSurfaceParent(MirWindow*);
     bool hasParent() const { return mParented; }
 
     QSurfaceFormat format() const { return mFormat; }
@@ -412,16 +437,16 @@
     QString persistentSurfaceId();
 
 private:
-    static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);
+    static void surfaceEventCallback(MirWindow* surface, const MirEvent *event, void* context);
     void postEvent(const MirEvent *event);
 
     QWindow * const mWindow;
-    UbuntuWindow * const mPlatformWindow;
-    UbuntuInput * const mInput;
+    QMirClientWindow * const mPlatformWindow;
+    QMirClientInput * const mInput;
     MirConnection * const mConnection;
-    UbuntuWindow * mParentWindowHandle{nullptr};
+    QMirClientWindow * mParentWindowHandle{nullptr};
 
-    MirSurface* mMirSurface;
+    MirWindow* mMirWindow;
     const EGLDisplay mEglDisplay;
     EGLSurface mEglSurface;
 
@@ -437,7 +462,7 @@
     QString mPersistentIdStr;
 };
 
-UbuntuSurface::UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection)
+UbuntuSurface::UbuntuSurface(QMirClientWindow *platformWindow, EGLDisplay display, QMirClientInput *input, MirConnection *connection)
     : mWindow(platformWindow->window())
     , mPlatformWindow(platformWindow)
     , mInput(input)
@@ -453,12 +478,12 @@
     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
+        // 1.4 context, but the XCB EGL backend tries to honor 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");
+            qCDebug(mirclientGraphics, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
             mFormat.setMajorVersion(1);
             mFormat.setMinorVersion(4);
             config = q_configFromGLFormat(display, mFormat, true);
@@ -475,24 +500,24 @@
     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.
+    // This is an optimization 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();
+    const auto outputId = static_cast<QMirClientScreen *>(mWindow->screen()->handle())->mirOutputId();
 
     mParentWindowHandle = getParentIfNecessary(mWindow, input);
 
-    mMirSurface = createMirSurface(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
-    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
+    mMirWindow = createMirWindow(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
+    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirWindow), nullptr);
 
-    mNeedsExposeCatchup = mir_surface_get_visibility(mMirSurface) == mir_surface_visibility_occluded;
+    mNeedsExposeCatchup = mir_window_get_visibility(mMirWindow) == mir_window_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);
+    MirWindowParameters parameters;
+    mir_window_get_parameters(mMirWindow, &parameters);
 
     auto geom = mWindow->geometry();
     geom.setWidth(parameters.width);
@@ -503,68 +528,68 @@
     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);
+    qCDebug(mirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title()
+                       << "role:" << roleFor(mWindow);
+    qCDebug(mirclientGraphics)
+                       << "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);
+    if (mMirWindow) {
+        mir_window_release_sync(mMirWindow);
     }
 }
 
 void UbuntuSurface::updateGeometry(const QRect &newGeometry)
 {
 
-    auto spec = Spec{mir_connection_create_spec_for_changes(mConnection)};
+    auto spec = Spec{mir_create_window_spec(mConnection)};
 
-    mir_surface_spec_set_width(spec.get(), newGeometry.width());
-    mir_surface_spec_set_height(spec.get(), newGeometry.height());
+    mir_window_spec_set_width(spec.get(), newGeometry.width());
+    mir_window_spec_set_height(spec.get(), newGeometry.height());
 
     MirRectangle mirRect {0,0,0,0};
 
     if (mParentWindowHandle) {
-        qCDebug(ubuntumirclient,"updateGeometry(window=%p, x=%d, y=%d, width=%d, height=%d, child)", mWindow,
+        qCDebug(mirclient,"updateGeometry(window=%p, x=%d, y=%d, width=%d, height=%d, child)", mWindow,
                 newGeometry.x(), newGeometry.y(), newGeometry.width(), newGeometry.height());
 
         mirRect.left = newGeometry.x() - mParentWindowHandle->window()->x();
         mirRect.top = newGeometry.y() - mParentWindowHandle->window()->y();
 
     } else {
-        qCDebug(ubuntumirclient,"updateGeometry(window=%p, x=%d, y=%d, width=%d, height=%d, top-level)", mWindow,
+        qCDebug(mirclient,"updateGeometry(window=%p, x=%d, y=%d, width=%d, height=%d, top-level)", mWindow,
                 newGeometry.x(), newGeometry.y(), newGeometry.width(), newGeometry.height());
 
         mirRect.left = newGeometry.x();
         mirRect.top = newGeometry.y();
     }
 
-    mir_surface_spec_set_placement(spec.get(), &mirRect,
+    mir_window_spec_set_placement(spec.get(), &mirRect,
             mir_placement_gravity_northwest /* rect_gravity */, mir_placement_gravity_northwest /* surface_gravity */,
             (MirPlacementHints)0, 0 /* offset_dx */, 0 /* offset_dy */);
 
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::updateTitle(const QString& newTitle)
 {
     const auto title = newTitle.toUtf8();
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    mir_surface_spec_set_name(spec.get(), title.constData());
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    Spec spec{mir_create_window_spec(mConnection)};
+    mir_window_spec_set_name(spec.get(), title.constData());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::setSizingConstraints(const QSize& minSize, const QSize& maxSize, const QSize& increment)
 {
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
+    Spec spec{mir_create_window_spec(mConnection)};
     ::setSizingConstraints(spec.get(), minSize, maxSize, increment);
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::handleSurfaceResized(int width, int height)
@@ -597,17 +622,17 @@
     return 0;
 }
 
-void UbuntuSurface::setState(MirSurfaceState state)
+void UbuntuSurface::setState(MirWindowState state)
 {
-    mir_wait_for(mir_surface_set_state(mMirSurface, state));
+    mir_window_set_state(mMirWindow, 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());
+        auto spec = Spec{mir_create_window_spec(mConnection)};
+        mir_window_spec_set_shell_chrome(spec.get(), chrome);
+        mir_window_apply_spec(mMirWindow, spec.get());
 
         mShellChrome = chrome;
     }
@@ -627,7 +652,7 @@
 
     if (validSize && (mBufferSize.width() != eglSurfaceWidth || mBufferSize.height() != eglSurfaceHeight)) {
 
-        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - size changed (%d, %d) => (%d, %d)",
+        qCDebug(mirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - size changed (%d, %d) => (%d, %d)",
                mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height(), eglSurfaceWidth, eglSurfaceHeight);
 
         mBufferSize.rwidth() = eglSurfaceWidth;
@@ -639,12 +664,12 @@
         mPlatformWindow->QPlatformWindow::setGeometry(newGeometry);
         QWindowSystemInterface::handleGeometryChange(mWindow, newGeometry);
     } else {
-        qCDebug(ubuntumirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size (%d,%d)",
+        qCDebug(mirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size (%d,%d)",
                mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height());
     }
 }
 
-void UbuntuSurface::surfaceEventCallback(MirSurface *surface, const MirEvent *event, void* context)
+void UbuntuSurface::surfaceEventCallback(MirWindow *surface, const MirEvent *event, void* context)
 {
     Q_UNUSED(surface);
     Q_ASSERT(context != nullptr);
@@ -664,7 +689,7 @@
         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);
+        qCDebug(mirclient, "resizeEvent(window=%p, width=%d, height=%d)", mWindow, width, height);
 
         QMutexLocker lock(&mTargetSizeMutex);
         mTargetSize.rwidth() = width;
@@ -674,48 +699,48 @@
     mInput->postEvent(mPlatformWindow, event);
 }
 
-void UbuntuSurface::setSurfaceParent(MirSurface* parent)
+void UbuntuSurface::setSurfaceParent(MirWindow* parent)
 {
-    qCDebug(ubuntumirclient, "setSurfaceParent(window=%p)", mWindow);
+    qCDebug(mirclient, "setSurfaceParent(window=%p)", mWindow);
 
     mParented = true;
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    mir_surface_spec_set_parent(spec.get(), parent);
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    Spec spec{mir_create_window_spec(mConnection)};
+    mir_window_spec_set_parent(spec.get(), parent);
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 QString UbuntuSurface::persistentSurfaceId()
 {
     if (mPersistentIdStr.isEmpty()) {
-        MirPersistentId* mirPermaId = mir_surface_request_persistent_id_sync(mMirSurface);
-        mPersistentIdStr = mir_persistent_id_as_string(mirPermaId);
-        mir_persistent_id_release(mirPermaId);
+        auto id = mir_window_request_window_id_sync(mMirWindow);
+        mPersistentIdStr = mir_window_id_as_string(id);
+        mir_window_id_release(id);
     }
     return mPersistentIdStr;
 }
 
-UbuntuWindow::UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface *native,
-                           UbuntuAppStateController *appState, EGLDisplay eglDisplay,
-                           MirConnection *mirConnection, UbuntuDebugExtension *debugExt)
+QMirClientWindow::QMirClientWindow(QWindow *w, QMirClientInput *input, QMirClientNativeInterface *native,
+                                   QMirClientAppStateController *appState, EGLDisplay eglDisplay,
+                                   MirConnection *mirConnection, QMirClientDebugExtension *debugExt)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
     , mWindowState(w->windowState())
     , mWindowFlags(w->flags())
     , mWindowVisible(false)
+    , mAppStateController(appState)
     , mDebugExtention(debugExt)
     , mNativeInterface(native)
-    , mAppStateController(appState)
     , mSurface(new UbuntuSurface{this, eglDisplay, input, mirConnection})
     , mScale(1.0)
     , mFormFactor(mir_form_factor_unknown)
 {
     mWindowExposed = mSurface->mNeedsExposeCatchup == false;
 
-    qCDebug(ubuntumirclient, "UbuntuWindow(window=%p, screen=%p, input=%p, surf=%p) with title '%s', role: '%d'",
+    qCDebug(mirclient, "QMirClientWindow(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()));
 
-    updatePanelHeightHack(mSurface->state() != mir_surface_state_fullscreen);
+    updatePanelHeightHack(mSurface->state() != mir_window_state_fullscreen);
 
     // queue the windowPropertyChanged signal. If it's emitted directly, the platformWindow will not yet be set for the window.
     QMetaObject::invokeMethod(mNativeInterface, "windowPropertyChanged", Qt::QueuedConnection,
@@ -723,15 +748,15 @@
                               Q_ARG(QString, "persistentSurfaceId"));
 }
 
-UbuntuWindow::~UbuntuWindow()
+QMirClientWindow::~QMirClientWindow()
 {
-    qCDebug(ubuntumirclient, "~UbuntuWindow(window=%p)", this);
+    qCDebug(mirclient, "~QMirClientWindow(window=%p)", this);
 }
 
-void UbuntuWindow::handleSurfaceResized(int width, int height)
+void QMirClientWindow::handleSurfaceResized(int width, int height)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p, size=(%dx%d)px", window(), width, height);
+    qCDebug(mirclient, "handleSurfaceResize(window=%p, size=(%dx%d)px", window(), width, height);
 
     mSurface->handleSurfaceResized(width, height);
 
@@ -742,17 +767,17 @@
     // 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);
+    qCDebug(mirclient, "handleSurfaceResize(window=%p) redraw %d times", window(), numRepaints);
     for (int i = 0; i < numRepaints; i++) {
-        qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) repainting size=(%dx%d)dp", window(), geometry().size().width(), geometry().size().height());
+        qCDebug(mirclient, "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)
+void QMirClientWindow::handleSurfaceExposeChange(bool exposed)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "handleSurfaceExposeChange(window=%p, exposed=%s)", window(), exposed ? "true" : "false");
+    qCDebug(mirclient, "handleSurfaceExposeChange(window=%p, exposed=%s)", window(), exposed ? "true" : "false");
 
     mSurface->mNeedsExposeCatchup = false;
     if (mWindowExposed == exposed) return;
@@ -762,22 +787,27 @@
     QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(), geometry().size()));
 }
 
-void UbuntuWindow::handleSurfaceFocusChanged(bool focused)
+void QMirClientWindow::handleSurfaceFocusChanged(bool focused)
 {
-    qCDebug(ubuntumirclient, "handleSurfaceFocusChanged(window=%p, focused=%d)", window(), focused);
+    qCDebug(mirclient, "handleSurfaceFocusChanged(window=%p, focused=%d)", window(), focused);
 
     if (focused) {
         mAppStateController->setWindowFocused(true);
         QWindowSystemInterface::handleWindowActivated(window(), Qt::ActiveWindowFocusReason);
     } else {
-        QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
-        mAppStateController->setWindowFocused(false);
+        // Flush events so that we update QGuiApplicationPrivate::focus_window first
+        QWindowSystemInterface::flushWindowSystemEvents(QEventLoop::ExcludeUserInputEvents);
+
+        if (window() == QGuiApplicationPrivate::focus_window) { // don't handle unfocus if this window wasn't currently focused.
+            QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
+            mAppStateController->setWindowFocused(false);
+        }
     }
 }
 
-void UbuntuWindow::handleSurfaceVisibilityChanged(bool visible)
+void QMirClientWindow::handleSurfaceVisibilityChanged(bool visible)
 {
-    qCDebug(ubuntumirclient, "handleSurfaceVisibilityChanged(window=%p, visible=%d)", window(), visible);
+    qCDebug(mirclient, "handleSurfaceVisibilityChanged(window=%p, visible=%d)", window(), visible);
 
     if (mWindowVisible == visible) return;
     mWindowVisible = visible;
@@ -785,9 +815,9 @@
     QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(), geometry().size()));
 }
 
-void UbuntuWindow::handleSurfaceStateChanged(Qt::WindowState state)
+void QMirClientWindow::handleSurfaceStateChanged(Qt::WindowState state)
 {
-    qCDebug(ubuntumirclient, "handleSurfaceStateChanged(window=%p, %s)", window(), qtWindowStateToStr(state));
+    qCDebug(mirclient, "handleSurfaceStateChanged(window=%p, %s)", window(), qtWindowStateToStr(state));
 
     if (mWindowState == state) return;
     mWindowState = state;
@@ -795,10 +825,10 @@
     QWindowSystemInterface::handleWindowStateChanged(window(), state);
 }
 
-void UbuntuWindow::setWindowState(Qt::WindowState state)
+void QMirClientWindow::setWindowState(Qt::WindowState state)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "setWindowState(window=%p, %s)", this, qtWindowStateToStr(state));
+    qCDebug(mirclient, "setWindowState(window=%p, %s)", this, qtWindowStateToStr(state));
 
     if (mWindowState == state) return;
     mWindowState = state;
@@ -807,10 +837,10 @@
     updateSurfaceState();
 }
 
-void UbuntuWindow::setWindowFlags(Qt::WindowFlags flags)