Merge lp:~gerboland/qtubuntu/upstream-closer into lp:qtubuntu

[Gerry Boland]

Class renaming and syntax changes to shrink delta with upstream mirclient QPA plugin (which is equivalent to rev 360)

Changes:
 - Rename classes to prefix "QMirClient" instead of "Ubuntu"
 - Update licence headers to match Qt's
 - change logging categories spec to match Qt: qt.qpa.mirclient
 - Enforce American English
 - some minor syntax tweaks

Some differences will still exist between lp:qtubuntu and upstream, some unavoidable:
 - QPA plugin remains "ubuntumirclient" and not "mirclient" as used upstream.
 - some header paths differ between in-Qt code and externally built code
 - I've not included build-type switches for things like accessibility support
 - relaxed switch cases to allow older versions of Mir not break a build
 - panel height hack removed from upstream
 - platform-api env var setting removed from upstream

This is designed to land *after* the following branches still in the queue:

lp:~nick-dedekind/qtubuntu/1648842.window-focus-regression
lp:~gerboland/qtubuntu/quit-gracefully-on-no-mirconnection
lp:~dandrader/qtubuntu/resizeToolTip

The resulting delta between this and Qt upstream can be seen in this diff:
http://pastebin.ubuntu.com/23858329/

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

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

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

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

Didn't check the code yet. But after building & installing it on my test machine unity8-dash (or any qt app) no longer comes up.

Log says:
This application failed to start because it could not find or load the Qt platform plugin "ubuntumirclient"

You sure you didn't rename the qpa?

[Daniel d'Andrada (dandrader)]

=== renamed and modified file src/ubuntumirclient/plugin.cpp => src/ubuntumirclient/qmirclientplugin.cpp

"""
- if (system.toLower() == QLatin1String("ubuntumirclient")) {
+ if (system.toLower() == QLatin1String("mirclient")) {
"""

Indeed you renamed it

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

The rest looks fine.

After undoing the rename of the platform, all works well again.

[Daniel d'Andrada (dandrader)]

all good now

review: Approve

[lp:~gerboland/qtubuntu/upstream-closer]

363. By Nick Dedekind on 2017-02-08

merged trunk

365. By Gerry Boland on 2017-01-25

Undo qpa plugin name change

=== modified file 'README'
--- README	2016-09-29 15:12:29 +0000
+++ README	2017-02-08 16:34:34 +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.
 
=== 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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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,12 @@
     window->setSurfaceType(QSurface::OpenGLSurface);
 }
 
-UbuntuBackingStore::~UbuntuBackingStore()
+QMirClientBackingStore::~QMirClientBackingStore()
 {
     mContext->makeCurrent(window()); // needed as QOpenGLTexture destructor assumes current context
 }
 
-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 +83,7 @@
     mContext->swapBuffers(window);
 }
 
-void UbuntuBackingStore::updateTexture()
+void QMirClientBackingStore::updateTexture()
 {
     if (mDirty.isNull())
         return;
@@ -76,9 +100,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 +113,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 +130,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 +145,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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-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 "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,13 +135,13 @@
 }
 } // 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();
+    MirSurface *surface = static_cast<QMirClientWindow*>(window->handle())->mirSurface();
 
     if (!surface) {
         return;
@@ -125,7 +149,7 @@
 
 
     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);
         } else if (windowCursor->shape() == Qt::BitmapCursor) {
@@ -143,7 +167,7 @@
 
 }
 
-void UbuntuCursor::configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor)
+void QMirClientCursor::configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor)
 {
     QImage image = cursor.pixmap().toImage();
 
@@ -177,7 +201,7 @@
     mir_buffer_stream_release_sync(bufferStream);
 }
 
-void UbuntuCursor::applyDefaultCursorConfiguration(MirSurface *surface)
+void QMirClientCursor::applyDefaultCursorConfiguration(MirSurface *surface)
 {
     auto cursorConfiguration = mir_cursor_configuration_from_name("left_ptr");
     mir_surface_configure_cursor(surface, 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-08 16:34:34 +0000
@@ -1,21 +1,45 @@
-/*
- * 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-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 QMIRCLIENTCURSOR_H
+#define QMIRCLIENTCURSOR_H
 
 #include <qpa/qplatformcursor.h>
 
@@ -25,10 +49,10 @@
 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);
@@ -37,4 +61,4 @@
     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-08 16:34:34 +0000
@@ -1,50 +1,74 @@
-/*
- * 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 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";
+    qCDebug(mirclientDebug) << "NOTICE: Loading mirclient-debug-extension";
     m_mapper = (MapperPrototype) m_mirclientDebug.resolve("mir_debug_surface_coords_to_screen");
 
     if (!m_mirclientDebug.isLoaded()) {
-        qCWarning(ubuntumirclientDebug) << "ERROR: mirclient-debug-extension failed to load:"
-                                        << m_mirclientDebug.errorString();
+        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::mapSurfacePointToScreen(MirSurface *surface, const QPoint &point)
 {
     if (!m_mapper) {
         return point;
 
=== 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-08 16:34:34 +0000
@@ -1,21 +1,45 @@
-/*
- * 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 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>
@@ -24,10 +48,10 @@
 typedef bool (*MapperPrototype)(MirSurface* surface, int x, int y, int* screenX, int* screenY);
 
 
-class UbuntuDebugExtension
+class QMirClientDebugExtension
 {
 public:
-    UbuntuDebugExtension();
+    QMirClientDebugExtension();
 
     bool isEnabled() const;
 
@@ -38,4 +62,4 @@
     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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-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 "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
 {
@@ -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.
 }
@@ -238,14 +262,14 @@
     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),
@@ -299,11 +323,11 @@
         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,11 +614,11 @@
     // 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::handleSurfaceEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceEvent *event)
 {
     auto surfaceEventAttribute = mir_surface_event_get_attribute(event);
 
@@ -604,10 +628,11 @@
                     mir_surface_event_get_attribute_value(event) == mir_surface_focused);
         break;
     }
-    case mir_surface_attrib_visibility:
+    case mir_surface_attrib_visibility: {
         window->handleSurfaceExposeChange(
                     mir_surface_event_get_attribute_value(event) == mir_surface_visibility_exposed);
         break;
+    }
     // Remaining attributes are ones client sets for server, and server should not override them
     case mir_surface_attrib_state: {
         MirSurfaceState state = static_cast<MirSurfaceState>(mir_surface_event_get_attribute_value(event));
@@ -630,7 +655,7 @@
     }
 }
 
-void UbuntuInput::handleSurfaceOutputEvent(const QPointer<UbuntuWindow> &window, const MirSurfaceOutputEvent *event)
+void QMirClientInput::handleSurfaceOutputEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceOutputEvent *event)
 {
     const uint32_t outputId = mir_surface_output_event_get_output_id(event);
     const int dpi = mir_surface_output_event_get_dpi(event);
@@ -638,9 +663,9 @@
     const float scale = mir_surface_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-08 16:34:34 +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-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 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 handleSurfaceEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceEvent *event);
+    void handleSurfaceOutputEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceOutputEvent *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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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 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("mirsurface", QMirClientNativeInterface::MirSurface);
+        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,7 +130,7 @@
     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();
@@ -115,7 +139,7 @@
         return mNativeOrientation;
     case MirSurface:
         if (window) {
-            auto ubuntuWindow = static_cast<UbuntuWindow*>(window->handle());
+            auto ubuntuWindow = static_cast<QMirClientWindow*>(window->handle());
             if (ubuntuWindow) {
                 return ubuntuWindow->mirSurface();
             } else {
@@ -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-08 16:34:34 +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 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 };
 
-    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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-08 16:34:34 +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-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 "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 {
@@ -196,10 +219,10 @@
     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)
@@ -222,7 +245,7 @@
     return requiresParent(qtWindowTypeToMirSurfaceType(type));
 }
 
-Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, UbuntuWindow *parentWindowHandle,
+Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, QMirClientWindow *parentWindowHandle,
                      MirConnection *connection)
 {
     const auto geometry = window->geometry();
@@ -273,7 +296,7 @@
         break;
     }
 
-    qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
+    qCDebug(mirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
             window, mirSurfaceTypeToStr(type), window->type(), location.left, location.top, width, height);
 
     return std::move(spec);
@@ -297,7 +320,7 @@
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuWindow *parentWindowHandle,
+MirSurface *createMirSurface(QWindow *window, int mirOutputId, QMirClientWindow *parentWindowHandle,
                              MirPixelFormat pixelFormat, MirConnection *connection,
                              mir_surface_event_callback inputCallback, void *inputContext)
 {
@@ -328,9 +351,9 @@
     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 +367,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 +401,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;
@@ -416,10 +439,10 @@
     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;
     const EGLDisplay mEglDisplay;
@@ -437,7 +460,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 +476,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,12 +498,12 @@
     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);
 
@@ -503,12 +526,12 @@
     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()
@@ -531,14 +554,14 @@
     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();
@@ -627,7 +650,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,7 +662,7 @@
         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());
     }
 }
@@ -664,7 +687,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;
@@ -676,7 +699,7 @@
 
 void UbuntuSurface::setSurfaceParent(MirSurface* parent)
 {
-    qCDebug(ubuntumirclient, "setSurfaceParent(window=%p)", mWindow);
+    qCDebug(mirclient, "setSurfaceParent(window=%p)", mWindow);
 
     mParented = true;
     Spec spec{mir_connection_create_spec_for_changes(mConnection)};
@@ -694,25 +717,25 @@
     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);
@@ -723,15 +746,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 +765,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 +785,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 +813,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 +823,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 +835,10 @@
     updateSurfaceState();
 }
 
-void UbuntuWindow::setWindowFlags(Qt::WindowFlags flags)
+void QMirClientWindow::setWindowFlags(Qt::WindowFlags flags)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "setWindowFlags(window=%p, 0x%x)", this, (int)flags);
+    qCDebug(mirclient, "setWindowFlags(window=%p, 0x%x)", this, (int)flags);
 
     if (mWindowFlags == flags) return;
     mWindowFlags = flags;
@@ -824,7 +852,7 @@
     window is always on the top-left corner, right below the indicators panel if not
     in fullscreen.
  */
-void UbuntuWindow::updatePanelHeightHack(bool enable)
+void QMirClientWindow::updatePanelHeightHack(bool enable)
 {
     if ((window()->type() & Qt::WindowType_Mask) != Qt::Window) { // only plain windows get the hack
         return;
@@ -846,7 +874,7 @@
     }
 }
 
-QRect UbuntuWindow::geometry() const
+QRect QMirClientWindow::geometry() const
 {
     if (mDebugExtention) {
         auto geom = QPlatformWindow::geometry();
@@ -857,16 +885,16 @@
     }
 }
 
-void UbuntuWindow::setGeometry(const QRect &rect)
+void QMirClientWindow::setGeometry(const QRect &rect)
 {
     QMutexLocker lock(&mMutex);
 
     if (window()->windowState() == Qt::WindowFullScreen || window()->windowState() == Qt::WindowMaximized) {
-        qCDebug(ubuntumirclient, "setGeometry(window=%p) - not resizing, window is maximized or fullscreen", window());
+        qCDebug(mirclient, "setGeometry(window=%p) - not resizing, window is maximized or fullscreen", window());
         return;
     }
 
-    qCDebug(ubuntumirclient, "setGeometry (window=%p, position=(%d, %d)dp, size=(%dx%d)dp)",
+    qCDebug(mirclient, "setGeometry (window=%p, position=(%d, %d)dp, size=(%dx%d)dp)",
             window(), rect.x(), rect.y(), rect.width(), rect.height());
     // Immediately update internal geometry so Qt believes position updated
     QRect newPosition(geometry());
@@ -877,10 +905,10 @@
     // Note: don't call handleGeometryChange here, wait to see what Mir replies with.
 }
 
-void UbuntuWindow::setVisible(bool visible)
+void QMirClientWindow::setVisible(bool visible)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "setVisible (window=%p, visible=%s)", window(), visible ? "true" : "false");
+    qCDebug(mirclient, "setVisible (window=%p, visible=%s)", window(), visible ? "true" : "false");
 
     if (mWindowVisible == visible) return;
     mWindowVisible = visible;
@@ -901,36 +929,36 @@
     QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(), geometry().size()));
 }
 
-void UbuntuWindow::setWindowTitle(const QString& title)
+void QMirClientWindow::setWindowTitle(const QString& title)
 {
     QMutexLocker lock(&mMutex);
-    qCDebug(ubuntumirclient, "setWindowTitle(window=%p) title=%s)", window(), title.toUtf8().constData());
+    qCDebug(mirclient, "setWindowTitle(window=%p) title=%s)", window(), title.toUtf8().constData());
     mSurface->updateTitle(title);
 }
 
-void UbuntuWindow::propagateSizeHints()
+void QMirClientWindow::propagateSizeHints()
 {
     QMutexLocker lock(&mMutex);
     const auto win = window();
-    qCDebug(ubuntumirclient, "propagateSizeHints(window=%p) min(%d,%d), max(%d,%d) increment(%d, %d)",
+    qCDebug(mirclient, "propagateSizeHints(window=%p) min(%d,%d), max(%d,%d) increment(%d, %d)",
             win, win->minimumSize().width(), win->minimumSize().height(),
             win->maximumSize().width(), win->maximumSize().height(),
             win->sizeIncrement().width(), win->sizeIncrement().height());
     mSurface->setSizingConstraints(win->minimumSize(), win->maximumSize(), win->sizeIncrement());
 }
 
-bool UbuntuWindow::isExposed() const
+bool QMirClientWindow::isExposed() const
 {
     // mNeedsExposeCatchup because we need to render a frame to get the expose surface event from mir.
     return mWindowVisible && (mWindowExposed || (mSurface && mSurface->mNeedsExposeCatchup));
 }
 
-QSurfaceFormat UbuntuWindow::format() const
+QSurfaceFormat QMirClientWindow::format() const
 {
     return mSurface->format();
 }
 
-QPoint UbuntuWindow::mapToGlobal(const QPoint &pos) const
+QPoint QMirClientWindow::mapToGlobal(const QPoint &pos) const
 {
     if (mDebugExtention) {
         return mDebugExtention->mapSurfacePointToScreen(mSurface->mirSurface(), pos);
@@ -939,22 +967,22 @@
     }
 }
 
-void* UbuntuWindow::eglSurface() const
+void* QMirClientWindow::eglSurface() const
 {
     return mSurface->eglSurface();
 }
 
-MirSurface *UbuntuWindow::mirSurface() const
+MirSurface *QMirClientWindow::mirSurface() const
 {
     return mSurface->mirSurface();
 }
 
-WId UbuntuWindow::winId() const
+WId QMirClientWindow::winId() const
 {
     return mId;
 }
 
-void UbuntuWindow::onSwapBuffersDone()
+void QMirClientWindow::onSwapBuffersDone()
 {
     QMutexLocker lock(&mMutex);
     mSurface->onSwapBuffersDone();
@@ -968,7 +996,7 @@
     }
 }
 
-void UbuntuWindow::handleScreenPropertiesChange(MirFormFactor formFactor, float scale)
+void QMirClientWindow::handleScreenPropertiesChange(MirFormFactor formFactor, float scale)
 {
     // Update the scale & form factor native-interface properties for the windows affected
     // as there is no convenient way to emit signals for those custom properties on a QScreen
@@ -986,12 +1014,12 @@
     }
 }
 
-void UbuntuWindow::updateSurfaceState()
+void QMirClientWindow::updateSurfaceState()
 {
     QMutexLocker lock(&mMutex);
     MirSurfaceState newState = mWindowVisible ? qtWindowStateToMirSurfaceState(mWindowState) :
                                                 mir_surface_state_hidden;
-    qCDebug(ubuntumirclient, "updateSurfaceState (window=%p, surfaceState=%s)", window(), mirSurfaceStateToStr(newState));
+    qCDebug(mirclient, "updateSurfaceState (window=%p, surfaceState=%s)", window(), mirSurfaceStateToStr(newState));
     if (newState != mSurface->state()) {
         mSurface->setState(newState);
 
@@ -1000,7 +1028,7 @@
     }
 }
 
-QString UbuntuWindow::persistentSurfaceId()
+QString QMirClientWindow::persistentSurfaceId()
 {
     return mSurface->persistentSurfaceId();
 }
 
=== renamed file 'src/ubuntumirclient/window.h' => 'src/ubuntumirclient/qmirclientwindow.h'
--- src/ubuntumirclient/window.h	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/qmirclientwindow.h	2017-02-08 16:34:34 +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_WINDOW_H
-#define UBUNTU_WINDOW_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 QMIRCLIENTWINDOW_H
+#define QMIRCLIENTWINDOW_H
 
 #include <qpa/qplatformwindow.h>
 #include <QSharedPointer>
@@ -27,23 +51,23 @@
 
 #include <EGL/egl.h>
 
-class UbuntuAppStateController;
-class UbuntuDebugExtension;
-class UbuntuNativeInterface;
-class UbuntuInput;
-class UbuntuScreen;
+class QMirClientAppStateController;
+class QMirClientDebugExtension;
+class QMirClientNativeInterface;
+class QMirClientInput;
+class QMirClientScreen;
 class UbuntuSurface;
 struct MirSurface;
 class MirConnection;
 
-class UbuntuWindow : public QObject, public QPlatformWindow
+class QMirClientWindow : public QObject, public QPlatformWindow
 {
     Q_OBJECT
 public:
-    UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface *native,
-                 UbuntuAppStateController *appState, EGLDisplay eglDisplay,
-                 MirConnection *mirConnection, UbuntuDebugExtension *debugExt);
-    virtual ~UbuntuWindow();
+    QMirClientWindow(QWindow *w, QMirClientInput *input, QMirClientNativeInterface *native,
+                     QMirClientAppStateController *appState, EGLDisplay eglDisplay,
+                     MirConnection *mirConnection, QMirClientDebugExtension *debugExt);
+    virtual ~QMirClientWindow();
 
     // QPlatformWindow methods.
     WId winId() const override;
@@ -84,14 +108,12 @@
     Qt::WindowFlags mWindowFlags;
     bool mWindowVisible;
     bool mWindowExposed;
-    UbuntuDebugExtension *mDebugExtention;
-    UbuntuNativeInterface *mNativeInterface;
-    UbuntuAppStateController *mAppStateController;
+    QMirClientAppStateController *mAppStateController;
+    QMirClientDebugExtension *mDebugExtention;
+    QMirClientNativeInterface *mNativeInterface;
     std::unique_ptr<UbuntuSurface> mSurface;
     float mScale;
     MirFormFactor mFormFactor;
 };
 
-Q_DECLARE_METATYPE(QPlatformWindow*);
-
-#endif // UBUNTU_WINDOW_H
+#endif // QMIRCLIENTWINDOW_H
 
=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2016-12-09 17:02:57 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2017-02-08 16:34:34 +0000
@@ -15,40 +15,40 @@
 PKGCONFIG += egl mirclient ubuntu-platform-api xkbcommon libcontent-hub
 
 SOURCES = \
-    backingstore.cpp \
-    clipboard.cpp \
-    cursor.cpp \
-    debugextension.cpp \
-    desktopwindow.cpp \
-    glcontext.cpp \
-    input.cpp \
-    integration.cpp \
-    nativeinterface.cpp \
-    platformservices.cpp \
-    plugin.cpp \
-    screen.cpp \
-    screenobserver.cpp \
-    window.cpp \
-    appstatecontroller.cpp
+    qmirclientbackingstore.cpp \
+    qmirclientclipboard.cpp \
+    qmirclientcursor.cpp \
+    qmirclientdebugextension.cpp \
+    qmirclientdesktopwindow.cpp \
+    qmirclientglcontext.cpp \
+    qmirclientinput.cpp \
+    qmirclientintegration.cpp \
+    qmirclientnativeinterface.cpp \
+    qmirclientplatformservices.cpp \
+    qmirclientplugin.cpp \
+    qmirclientscreen.cpp \
+    qmirclientscreenobserver.cpp \
+    qmirclientwindow.cpp \
+    qmirclientappstatecontroller.cpp
 
 HEADERS = \
-    backingstore.h \
-    clipboard.h \
-    cursor.h \
-    debugextension.h \
-    desktopwindow.h \
-    glcontext.h \
-    input.h \
-    integration.h \
-    nativeinterface.h \
-    orientationchangeevent_p.h \
-    platformservices.h \
-    plugin.h \
-    screenobserver.h \
-    screen.h \
-    window.h \
-    logging.h \
-    appstatecontroller.h
+    qmirclientbackingstore.h \
+    qmirclientclipboard.h \
+    qmirclientcursor.h \
+    qmirclientdebugextension.h \
+    qmirclientdesktopwindow.h \
+    qmirclientglcontext.h \
+    qmirclientinput.h \
+    qmirclientintegration.h \
+    qmirclientnativeinterface.h \
+    qmirclientorientationchangeevent_p.h \
+    qmirclientplatformservices.h \
+    qmirclientplugin.h \
+    qmirclientscreenobserver.h \
+    qmirclientscreen.h \
+    qmirclientwindow.h \
+    qmirclientlogging.h \
+    qmirclientappstatecontroller.h
 
 OTHER_FILES += \
     ubuntumirclient.json