Merge remote-tracking branch 'origin/5.7' into dev

Conflicts:
	.qmake.conf
	examples/wayland/minimal-qml/main.qml

Change-Id: Ic34029a6aa77f2b359f40258a05421d82efd5b37

23 files changed, 302 insertions, 252 deletions

diff --git a/examples/wayland/minimal-qml/main.qml b/examples/wayland/minimal-qml/main.qml
index 217764a59..dde223859 100644
--- a/examples/wayland/minimal-qml/main.qml
+++ b/examples/wayland/minimal-qml/main.qml
@@ -51,14 +51,10 @@ WaylandCompositor {
             width: 1024
             height: 768
             visible: true
-            WaylandMouseTracker {
+            Rectangle {
+                id: surfaceArea
+                color: "#1337af"
                 anchors.fill: parent
-                windowSystemCursorEnabled: true
-                Rectangle {
-                    id: surfaceArea
-                    color: "#1337af"
-                    anchors.fill: parent
-                }
             }
         }
     }
diff --git a/examples/wayland/qwindow-compositor/windowcompositor.cpp b/examples/wayland/qwindow-compositor/compositor.cpp
index 31126ad85..4999a5ed0 100644
--- a/examples/wayland/qwindow-compositor/windowcompositor.cpp
+++ b/examples/wayland/qwindow-compositor/compositor.cpp
@@ -38,7 +38,7 @@
 **
 ****************************************************************************/
 
-#include "windowcompositor.h"
+#include "compositor.h"
 
 #include <QMouseEvent>
 #include <QKeyEvent>
@@ -56,7 +56,7 @@
 #define GL_TEXTURE_EXTERNAL_OES 0x8D65
 #endif
 
-WindowCompositorView::WindowCompositorView()
+View::View()
     : m_textureTarget(GL_TEXTURE_2D)
     , m_texture(0)
     , m_wlShellSurface(nullptr)
@@ -65,7 +65,7 @@ WindowCompositorView::WindowCompositorView()
     , m_parentView(nullptr)
 {}
 
-GLuint WindowCompositorView::getTexture(GLenum *target)
+GLuint View::getTexture(GLenum *target)
 {
     QWaylandBufferRef buf = currentBuffer();
     GLuint streamingTexture = buf.textureForPlane(0);
@@ -94,12 +94,12 @@ GLuint WindowCompositorView::getTexture(GLenum *target)
     return m_texture;
 }
 
-bool WindowCompositorView::isCursor() const
+bool View::isCursor() const
 {
     return surface()->isCursorSurface();
 }
 
-void WindowCompositorView::onXdgSetMaximized()
+void View::onXdgSetMaximized()
 {
     m_xdgSurface->sendMaximized(output()->geometry().size());
 
@@ -110,12 +110,12 @@ void WindowCompositorView::onXdgSetMaximized()
     setPosition(QPoint(0, 0));
 }
 
-void WindowCompositorView::onXdgUnsetMaximized()
+void View::onXdgUnsetMaximized()
 {
     m_xdgSurface->sendUnmaximized();
 }
 
-void WindowCompositorView::onXdgSetFullscreen(QWaylandOutput* clientPreferredOutput)
+void View::onXdgSetFullscreen(QWaylandOutput* clientPreferredOutput)
 {
     QWaylandOutput *outputToFullscreen = clientPreferredOutput
             ? clientPreferredOutput
@@ -130,61 +130,61 @@ void WindowCompositorView::onXdgSetFullscreen(QWaylandOutput* clientPreferredOut
     setPosition(outputToFullscreen->position());
 }
 
-void WindowCompositorView::onOffsetForNextFrame(const QPoint &offset)
+void View::onOffsetForNextFrame(const QPoint &offset)
 {
     m_offset = offset;
     setPosition(position() + offset);
 }
 
-void WindowCompositorView::onXdgUnsetFullscreen()
+void View::onXdgUnsetFullscreen()
 {
     onXdgUnsetMaximized();
 }
 
-WindowCompositor::WindowCompositor(QWindow *window)
+Compositor::Compositor(QWindow *window)
     : QWaylandCompositor()
     , m_window(window)
     , m_wlShell(new QWaylandWlShell(this))
     , m_xdgShell(new QWaylandXdgShell(this))
 {
-    connect(m_wlShell, &QWaylandWlShell::shellSurfaceCreated, this, &WindowCompositor::onWlShellSurfaceCreated);
-    connect(m_xdgShell, &QWaylandXdgShell::xdgSurfaceCreated, this, &WindowCompositor::onXdgSurfaceCreated);
-    connect(m_xdgShell, &QWaylandXdgShell::createXdgPopup, this, &WindowCompositor::onCreateXdgPopup);
+    connect(m_wlShell, &QWaylandWlShell::shellSurfaceCreated, this, &Compositor::onWlShellSurfaceCreated);
+    connect(m_xdgShell, &QWaylandXdgShell::xdgSurfaceCreated, this, &Compositor::onXdgSurfaceCreated);
+    connect(m_xdgShell, &QWaylandXdgShell::createXdgPopup, this, &Compositor::onCreateXdgPopup);
 }
 
-WindowCompositor::~WindowCompositor()
+Compositor::~Compositor()
 {
 }
 
-void WindowCompositor::create()
+void Compositor::create()
 {
     new QWaylandOutput(this, m_window);
     QWaylandCompositor::create();
 
-    connect(this, &QWaylandCompositor::surfaceCreated, this, &WindowCompositor::onSurfaceCreated);
-    connect(defaultInputDevice(), &QWaylandInputDevice::cursorSurfaceRequest, this, &WindowCompositor::adjustCursorSurface);
-    connect(defaultInputDevice()->drag(), &QWaylandDrag::dragStarted, this, &WindowCompositor::startDrag);
+    connect(this, &QWaylandCompositor::surfaceCreated, this, &Compositor::onSurfaceCreated);
+    connect(defaultInputDevice(), &QWaylandInputDevice::cursorSurfaceRequest, this, &Compositor::adjustCursorSurface);
+    connect(defaultInputDevice()->drag(), &QWaylandDrag::dragStarted, this, &Compositor::startDrag);
 
-    connect(this, &QWaylandCompositor::subsurfaceChanged, this, &WindowCompositor::onSubsurfaceChanged);
+    connect(this, &QWaylandCompositor::subsurfaceChanged, this, &Compositor::onSubsurfaceChanged);
 }
 
-void WindowCompositor::onSurfaceCreated(QWaylandSurface *surface)
+void Compositor::onSurfaceCreated(QWaylandSurface *surface)
 {
-    connect(surface, &QWaylandSurface::surfaceDestroyed, this, &WindowCompositor::surfaceDestroyed);
-    connect(surface, &QWaylandSurface::mappedChanged, this, &WindowCompositor::surfaceMappedChanged);
-    connect(surface, &QWaylandSurface::redraw, this, &WindowCompositor::triggerRender);
+    connect(surface, &QWaylandSurface::surfaceDestroyed, this, &Compositor::surfaceDestroyed);
+    connect(surface, &QWaylandSurface::mappedChanged, this, &Compositor::surfaceMappedChanged);
+    connect(surface, &QWaylandSurface::redraw, this, &Compositor::triggerRender);
 
-    connect(surface, &QWaylandSurface::subsurfacePositionChanged, this, &WindowCompositor::onSubsurfacePositionChanged);
+    connect(surface, &QWaylandSurface::subsurfacePositionChanged, this, &Compositor::onSubsurfacePositionChanged);
 
-    WindowCompositorView *view = new WindowCompositorView;
+    View *view = new View;
     view->setSurface(surface);
     view->setOutput(outputFor(m_window));
     m_views << view;
-    connect(view, &QWaylandView::surfaceDestroyed, this, &WindowCompositor::viewSurfaceDestroyed);
-    connect(surface, &QWaylandSurface::offsetForNextFrame, view, &WindowCompositorView::onOffsetForNextFrame);
+    connect(view, &QWaylandView::surfaceDestroyed, this, &Compositor::viewSurfaceDestroyed);
+    connect(surface, &QWaylandSurface::offsetForNextFrame, view, &View::onOffsetForNextFrame);
 }
 
-void WindowCompositor::surfaceMappedChanged()
+void Compositor::surfaceMappedChanged()
 {
     QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
     if (surface->isMapped()) {
@@ -204,55 +204,55 @@ void WindowCompositor::surfaceMappedChanged()
     triggerRender();
 }
 
-void WindowCompositor::surfaceDestroyed()
+void Compositor::surfaceDestroyed()
 {
     triggerRender();
 }
 
-void WindowCompositor::viewSurfaceDestroyed()
+void Compositor::viewSurfaceDestroyed()
 {
-    WindowCompositorView *view = qobject_cast<WindowCompositorView*>(sender());
+    View *view = qobject_cast<View*>(sender());
     m_views.removeAll(view);
     delete view;
 }
 
-WindowCompositorView * WindowCompositor::findView(const QWaylandSurface *s) const
+View * Compositor::findView(const QWaylandSurface *s) const
 {
-    Q_FOREACH (WindowCompositorView* view, m_views) {
+    Q_FOREACH (View* view, m_views) {
         if (view->surface() == s)
             return view;
     }
     return Q_NULLPTR;
 }
 
-void WindowCompositor::onWlShellSurfaceCreated(QWaylandWlShellSurface *wlShellSurface)
+void Compositor::onWlShellSurfaceCreated(QWaylandWlShellSurface *wlShellSurface)
 {
-    connect(wlShellSurface, &QWaylandWlShellSurface::startMove, this, &WindowCompositor::onStartMove);
-    connect(wlShellSurface, &QWaylandWlShellSurface::startResize, this, &WindowCompositor::onWlStartResize);
-    connect(wlShellSurface, &QWaylandWlShellSurface::setTransient, this, &WindowCompositor::onSetTransient);
-    connect(wlShellSurface, &QWaylandWlShellSurface::setPopup, this, &WindowCompositor::onSetPopup);
+    connect(wlShellSurface, &QWaylandWlShellSurface::startMove, this, &Compositor::onStartMove);
+    connect(wlShellSurface, &QWaylandWlShellSurface::startResize, this, &Compositor::onWlStartResize);
+    connect(wlShellSurface, &QWaylandWlShellSurface::setTransient, this, &Compositor::onSetTransient);
+    connect(wlShellSurface, &QWaylandWlShellSurface::setPopup, this, &Compositor::onSetPopup);
 
-    WindowCompositorView *view = findView(wlShellSurface->surface());
+    View *view = findView(wlShellSurface->surface());
     Q_ASSERT(view);
     view->m_wlShellSurface = wlShellSurface;
 }
 
-void WindowCompositor::onXdgSurfaceCreated(QWaylandXdgSurface *xdgSurface)
+void Compositor::onXdgSurfaceCreated(QWaylandXdgSurface *xdgSurface)
 {
-    connect(xdgSurface, &QWaylandXdgSurface::startMove, this, &WindowCompositor::onStartMove);
-    connect(xdgSurface, &QWaylandXdgSurface::startResize, this, &WindowCompositor::onXdgStartResize);
+    connect(xdgSurface, &QWaylandXdgSurface::startMove, this, &Compositor::onStartMove);
+    connect(xdgSurface, &QWaylandXdgSurface::startResize, this, &Compositor::onXdgStartResize);
 
-    WindowCompositorView *view = findView(xdgSurface->surface());
+    View *view = findView(xdgSurface->surface());
     Q_ASSERT(view);
     view->m_xdgSurface = xdgSurface;
 
-    connect(xdgSurface, &QWaylandXdgSurface::setMaximized, view, &WindowCompositorView::onXdgSetMaximized);
-    connect(xdgSurface, &QWaylandXdgSurface::setFullscreen, view, &WindowCompositorView::onXdgSetFullscreen);
-    connect(xdgSurface, &QWaylandXdgSurface::unsetMaximized, view, &WindowCompositorView::onXdgUnsetMaximized);
-    connect(xdgSurface, &QWaylandXdgSurface::unsetFullscreen, view, &WindowCompositorView::onXdgUnsetFullscreen);
+    connect(xdgSurface, &QWaylandXdgSurface::setMaximized, view, &View::onXdgSetMaximized);
+    connect(xdgSurface, &QWaylandXdgSurface::setFullscreen, view, &View::onXdgSetFullscreen);
+    connect(xdgSurface, &QWaylandXdgSurface::unsetMaximized, view, &View::onXdgUnsetMaximized);
+    connect(xdgSurface, &QWaylandXdgSurface::unsetFullscreen, view, &View::onXdgUnsetFullscreen);
 }
 
-void WindowCompositor::onCreateXdgPopup(QWaylandSurface *surface, QWaylandSurface *parent,
+void Compositor::onCreateXdgPopup(QWaylandSurface *surface, QWaylandSurface *parent,
                                         QWaylandInputDevice *inputDevice, const QPoint &position,
                                         const QWaylandResource &resource)
 {
@@ -260,100 +260,100 @@ void WindowCompositor::onCreateXdgPopup(QWaylandSurface *surface, QWaylandSurfac
 
     QWaylandXdgPopup *xdgPopup = new QWaylandXdgPopup(m_xdgShell, surface, parent, position, resource);
 
-    WindowCompositorView *view = findView(surface);
+    View *view = findView(surface);
     Q_ASSERT(view);
 
-    WindowCompositorView *parentView = findView(parent);
+    View *parentView = findView(parent);
     Q_ASSERT(parentView);
 
     view->setPosition(parentView->position() + position);
     view->m_xdgPopup = xdgPopup;
 }
 
-void WindowCompositor::onStartMove()
+void Compositor::onStartMove()
 {
     closePopups();
     emit startMove();
 }
 
-void WindowCompositor::onWlStartResize(QWaylandInputDevice *, QWaylandWlShellSurface::ResizeEdge edges)
+void Compositor::onWlStartResize(QWaylandInputDevice *, QWaylandWlShellSurface::ResizeEdge edges)
 {
     closePopups();
     emit startResize(int(edges), false);
 }
 
-void WindowCompositor::onXdgStartResize(QWaylandInputDevice *inputDevice,
+void Compositor::onXdgStartResize(QWaylandInputDevice *inputDevice,
                                         QWaylandXdgSurface::ResizeEdge edges)
 {
     Q_UNUSED(inputDevice);
     emit startResize(int(edges), true);
 }
 
-void WindowCompositor::onSetTransient(QWaylandSurface *parent, const QPoint &relativeToParent, QWaylandWlShellSurface::FocusPolicy focusPolicy)
+void Compositor::onSetTransient(QWaylandSurface *parent, const QPoint &relativeToParent, QWaylandWlShellSurface::FocusPolicy focusPolicy)
 {
     Q_UNUSED(focusPolicy);
     QWaylandWlShellSurface *wlShellSurface = qobject_cast<QWaylandWlShellSurface*>(sender());
-    WindowCompositorView *view = findView(wlShellSurface->surface());
+    View *view = findView(wlShellSurface->surface());
 
     if (view) {
         raise(view);
-        WindowCompositorView *parentView = findView(parent);
+        View *parentView = findView(parent);
         if (parentView)
             view->setPosition(parentView->position() + relativeToParent);
     }
 }
 
-void WindowCompositor::onSetPopup(QWaylandInputDevice *inputDevice, QWaylandSurface *parent, const QPoint &relativeToParent)
+void Compositor::onSetPopup(QWaylandInputDevice *inputDevice, QWaylandSurface *parent, const QPoint &relativeToParent)
 {
     Q_UNUSED(inputDevice);
     QWaylandWlShellSurface *surface = qobject_cast<QWaylandWlShellSurface*>(sender());
-    WindowCompositorView *view = findView(surface->surface());
+    View *view = findView(surface->surface());
     m_popupViews << view;
     if (view) {
         raise(view);
-        WindowCompositorView *parentView = findView(parent);
+        View *parentView = findView(parent);
         if (parentView)
             view->setPosition(parentView->position() + relativeToParent);
     }
 }
 
-void WindowCompositor::onSubsurfaceChanged(QWaylandSurface *child, QWaylandSurface *parent)
+void Compositor::onSubsurfaceChanged(QWaylandSurface *child, QWaylandSurface *parent)
 {
-    WindowCompositorView *view = findView(child);
-    WindowCompositorView *parentView = findView(parent);
+    View *view = findView(child);
+    View *parentView = findView(parent);
     view->setParentView(parentView);
 }
 
-void WindowCompositor::onSubsurfacePositionChanged(const QPoint &position)
+void Compositor::onSubsurfacePositionChanged(const QPoint &position)
 {
     QWaylandSurface *surface = qobject_cast<QWaylandSurface*>(sender());
     if (!surface)
         return;
-    WindowCompositorView *view = findView(surface);
+    View *view = findView(surface);
     view->setPosition(position);
     triggerRender();
 }
 
-void WindowCompositor::triggerRender()
+void Compositor::triggerRender()
 {
     m_window->requestUpdate();
 }
 
-void WindowCompositor::startRender()
+void Compositor::startRender()
 {
     QWaylandOutput *out = defaultOutput();
     if (out)
         out->frameStarted();
 }
 
-void WindowCompositor::endRender()
+void Compositor::endRender()
 {
     QWaylandOutput *out = defaultOutput();
     if (out)
         out->sendFrameCallbacks();
 }
 
-void WindowCompositor::updateCursor()
+void Compositor::updateCursor()
 {
     m_cursorView.advance();
     QImage image = m_cursorView.currentBuffer().image();
@@ -361,13 +361,13 @@ void WindowCompositor::updateCursor()
         m_window->setCursor(QCursor(QPixmap::fromImage(image), m_cursorHotspotX, m_cursorHotspotY));
 }
 
-void WindowCompositor::adjustCursorSurface(QWaylandSurface *surface, int hotspotX, int hotspotY)
+void Compositor::adjustCursorSurface(QWaylandSurface *surface, int hotspotX, int hotspotY)
 {
     if ((m_cursorView.surface() != surface)) {
         if (m_cursorView.surface())
-            disconnect(m_cursorView.surface(), &QWaylandSurface::redraw, this, &WindowCompositor::updateCursor);
+            disconnect(m_cursorView.surface(), &QWaylandSurface::redraw, this, &Compositor::updateCursor);
         if (surface)
-            connect(surface, &QWaylandSurface::redraw, this, &WindowCompositor::updateCursor);
+            connect(surface, &QWaylandSurface::redraw, this, &Compositor::updateCursor);
     }
 
     m_cursorView.setSurface(surface);
@@ -378,9 +378,9 @@ void WindowCompositor::adjustCursorSurface(QWaylandSurface *surface, int hotspot
         updateCursor();
 }
 
-void WindowCompositor::closePopups()
+void Compositor::closePopups()
 {
-    Q_FOREACH (WindowCompositorView *view, m_popupViews) {
+    Q_FOREACH (View *view, m_popupViews) {
         if (view->m_wlShellSurface)
             view->m_wlShellSurface->sendPopupDone();
     }
@@ -389,7 +389,7 @@ void WindowCompositor::closePopups()
     m_xdgShell->closeAllPopups();
 }
 
-void WindowCompositor::handleMouseEvent(QWaylandView *target, QMouseEvent *me)
+void Compositor::handleMouseEvent(QWaylandView *target, QMouseEvent *me)
 {
     if (target && popupActive() && me->type() == QEvent::MouseButtonPress
         && target->surface()->client() != m_popupViews.first()->surface()->client()) {
@@ -419,7 +419,7 @@ void WindowCompositor::handleMouseEvent(QWaylandView *target, QMouseEvent *me)
     }
 }
 
-void WindowCompositor::handleResize(WindowCompositorView *target, const QSize &initialSize, const QPoint &delta, int edge)
+void Compositor::handleResize(View *target, const QSize &initialSize, const QPoint &delta, int edge)
 {
     QWaylandWlShellSurface *wlShellSurface = target->m_wlShellSurface;
     if (wlShellSurface) {
@@ -436,17 +436,17 @@ void WindowCompositor::handleResize(WindowCompositorView *target, const QSize &i
     }
 }
 
-void WindowCompositor::startDrag()
+void Compositor::startDrag()
 {
     QWaylandDrag *currentDrag = defaultInputDevice()->drag();
     Q_ASSERT(currentDrag);
-    WindowCompositorView *iconView = findView(currentDrag->icon());
+    View *iconView = findView(currentDrag->icon());
     iconView->setPosition(m_window->mapFromGlobal(QCursor::pos()));
 
     emit dragStarted(iconView);
 }
 
-void WindowCompositor::handleDrag(WindowCompositorView *target, QMouseEvent *me)
+void Compositor::handleDrag(View *target, QMouseEvent *me)
 {
     QPointF pos = me->localPos();
     QWaylandSurface *surface = 0;
@@ -464,10 +464,10 @@ void WindowCompositor::handleDrag(WindowCompositorView *target, QMouseEvent *me)
 // so maintaining a stacking order gets a bit complex. A better data
 // structure is left as an exercise for the reader.
 
-static int findEndOfChildTree(const QList<WindowCompositorView*> &list, int index)
+static int findEndOfChildTree(const QList<View*> &list, int index)
 {
     int n = list.count();
-    WindowCompositorView *parent = list.at(index);
+    View *parent = list.at(index);
     while (index + 1 < n) {
         if (list.at(index+1)->parentView() != parent)
             break;
@@ -476,7 +476,7 @@ static int findEndOfChildTree(const QList<WindowCompositorView*> &list, int inde
     return index;
 }
 
-void WindowCompositor::raise(WindowCompositorView *view)
+void Compositor::raise(View *view)
 {
     int startPos = m_views.indexOf(view);
     int endPos = findEndOfChildTree(m_views, startPos);
diff --git a/examples/wayland/qwindow-compositor/windowcompositor.h b/examples/wayland/qwindow-compositor/compositor.h
index 80a7bebe4..8eec0a58f 100644
--- a/examples/wayland/qwindow-compositor/windowcompositor.h
+++ b/examples/wayland/qwindow-compositor/compositor.h
@@ -54,31 +54,31 @@ class QWaylandWlShell;
 class QWaylandWlShellSurface;
 class QWaylandXdgShell;
 
-class WindowCompositorView : public QWaylandView
+class View : public QWaylandView
 {
     Q_OBJECT
 public:
-    WindowCompositorView();
+    View();
     GLuint getTexture(GLenum *target = 0);
     QPointF position() const { return m_position; }
     void setPosition(const QPointF &pos) { m_position = pos; }
     bool isCursor() const;
     bool hasShell() const { return m_wlShellSurface; }
-    void setParentView(WindowCompositorView *parent) { m_parentView = parent; }
-    WindowCompositorView *parentView() const { return m_parentView; }
+    void setParentView(View *parent) { m_parentView = parent; }
+    View *parentView() const { return m_parentView; }
     QPointF parentPosition() const { return m_parentView ? (m_parentView->position() + m_parentView->parentPosition()) : QPointF(); }
     QSize windowSize() { return m_xdgSurface ? m_xdgSurface->windowGeometry().size() : surface()->size(); }
     QPoint offset() const { return m_offset; }
 
 private:
-    friend class WindowCompositor;
+    friend class Compositor;
     GLenum m_textureTarget;
     GLuint m_texture;
     QPointF m_position;
     QWaylandWlShellSurface *m_wlShellSurface;
     QWaylandXdgSurface *m_xdgSurface;
     QWaylandXdgPopup *m_xdgPopup;
-    WindowCompositorView *m_parentView;
+    View *m_parentView;
     QPoint m_offset;
 
 public slots:
@@ -89,23 +89,23 @@ public slots:
     void onOffsetForNextFrame(const QPoint &offset);
 };
 
-class WindowCompositor : public QWaylandCompositor
+class Compositor : public QWaylandCompositor
 {
     Q_OBJECT
 public:
-    WindowCompositor(QWindow *window);
-    ~WindowCompositor();
+    Compositor(QWindow *window);
+    ~Compositor();
     void create() Q_DECL_OVERRIDE;
 
     void startRender();
     void endRender();
 
-    QList<WindowCompositorView*> views() const { return m_views; }
-    void raise(WindowCompositorView *view);
+    QList<View*> views() const { return m_views; }
+    void raise(View *view);
 
     void handleMouseEvent(QWaylandView *target, QMouseEvent *me);
-    void handleResize(WindowCompositorView *target, const QSize &initialSize, const QPoint &delta, int edge);
-    void handleDrag(WindowCompositorView *target, QMouseEvent *me);
+    void handleResize(View *target, const QSize &initialSize, const QPoint &delta, int edge);
+    void handleDrag(View *target, QMouseEvent *me);
 
     bool popupActive() const { return !m_popupViews.isEmpty(); }
     void closePopups();
@@ -115,7 +115,7 @@ protected:
 signals:
     void startMove();
     void startResize(int edge, bool anchored);
-    void dragStarted(WindowCompositorView *dragIcon);
+    void dragStarted(View *dragIcon);
     void frameOffset(const QPoint &offset);
 
 private slots:
@@ -143,10 +143,10 @@ private slots:
 
     void updateCursor();
 private:
-    WindowCompositorView *findView(const QWaylandSurface *s) const;
+    View *findView(const QWaylandSurface *s) const;
     QWindow *m_window;
-    QList<WindowCompositorView*> m_views;
-    QList<WindowCompositorView*> m_popupViews;
+    QList<View*> m_views;
+    QList<View*> m_popupViews;
     QWaylandWlShell *m_wlShell;
     QWaylandXdgShell *m_xdgShell;
     QWaylandView m_cursorView;
diff --git a/examples/wayland/qwindow-compositor/main.cpp b/examples/wayland/qwindow-compositor/main.cpp
index c4fa43256..7ca868fce 100644
--- a/examples/wayland/qwindow-compositor/main.cpp
+++ b/examples/wayland/qwindow-compositor/main.cpp
@@ -39,15 +39,15 @@
 ****************************************************************************/
 
 #include <QGuiApplication>
-#include "compositorwindow.h"
-#include "windowcompositor.h"
+#include "window.h"
+#include "compositor.h"
 
 int main(int argc, char *argv[])
 {
     QGuiApplication app(argc, argv);
 
-    CompositorWindow window;
-    WindowCompositor compositor(&window);
+    Window window;
+    Compositor compositor(&window);
     window.setCompositor(&compositor);
     compositor.create();
     window.resize(800,600);
diff --git a/examples/wayland/qwindow-compositor/qwindow-compositor.pro b/examples/wayland/qwindow-compositor/qwindow-compositor.pro
index 6e23dc820..8cc7279d1 100644
--- a/examples/wayland/qwindow-compositor/qwindow-compositor.pro
+++ b/examples/wayland/qwindow-compositor/qwindow-compositor.pro
@@ -3,12 +3,12 @@ QT += gui gui-private core-private waylandcompositor waylandcompositor-private
 LIBS += -L ../../lib
 
 HEADERS += \
-    compositorwindow.h \
-    windowcompositor.h
+    window.h \
+    compositor.h
 
 SOURCES += main.cpp \
-    compositorwindow.cpp \
-    windowcompositor.cpp
+    window.cpp \
+    compositor.cpp
 
 # to make QtWaylandCompositor/... style includes working without installing
 INCLUDEPATH += $$PWD/../../include
diff --git a/examples/wayland/qwindow-compositor/compositorwindow.cpp b/examples/wayland/qwindow-compositor/window.cpp
index 537a3d08a..c3fc9b7df 100644
--- a/examples/wayland/qwindow-compositor/compositorwindow.cpp
+++ b/examples/wayland/qwindow-compositor/window.cpp
@@ -38,7 +38,7 @@
 **
 ****************************************************************************/
 
-#include "compositorwindow.h"
+#include "window.h"
 
 #include <QMouseEvent>
 #include <QOpenGLWindow>
@@ -46,10 +46,10 @@
 #include <QOpenGLFunctions>
 #include <QMatrix4x4>
 
-#include "windowcompositor.h"
+#include "compositor.h"
 #include <QtWaylandCompositor/qwaylandinput.h>
 
-CompositorWindow::CompositorWindow()
+Window::Window()
     : m_backgroundTexture(0)
     , m_compositor(0)
     , m_grabState(NoGrab)
@@ -57,14 +57,14 @@ CompositorWindow::CompositorWindow()
 {
 }
 
-void CompositorWindow::setCompositor(WindowCompositor *comp) {
+void Window::setCompositor(Compositor *comp) {
     m_compositor = comp;
-    connect(m_compositor, &WindowCompositor::startMove, this, &CompositorWindow::startMove);
-    connect(m_compositor, &WindowCompositor::startResize, this, &CompositorWindow::startResize);
-    connect(m_compositor, &WindowCompositor::dragStarted, this, &CompositorWindow::startDrag);
+    connect(m_compositor, &Compositor::startMove, this, &Window::startMove);
+    connect(m_compositor, &Compositor::startResize, this, &Window::startResize);
+    connect(m_compositor, &Compositor::dragStarted, this, &Window::startDrag);
 }
 
-void CompositorWindow::initializeGL()
+void Window::initializeGL()
 {
     QImage backgroundImage = QImage(QLatin1String(":/background.jpg"));
     m_backgroundTexture = new QOpenGLTexture(backgroundImage, QOpenGLTexture::DontGenerateMipMaps);
@@ -73,7 +73,7 @@ void CompositorWindow::initializeGL()
     m_textureBlitter.create();
 }
 
-void CompositorWindow::drawBackground()
+void Window::drawBackground()
 {
     for (int y = 0; y < height(); y += m_backgroundImageSize.height()) {
         for (int x = 0; x < width(); x += m_backgroundImageSize.width()) {
@@ -85,7 +85,7 @@ void CompositorWindow::drawBackground()
     }
 }
 
-QPointF CompositorWindow::getAnchorPosition(const QPointF &position, int resizeEdge, const QSize &windowSize)
+QPointF Window::getAnchorPosition(const QPointF &position, int resizeEdge, const QSize &windowSize)
 {
     float y = position.y();
     if (resizeEdge & QWaylandXdgSurface::ResizeEdge::TopEdge)
@@ -98,12 +98,12 @@ QPointF CompositorWindow::getAnchorPosition(const QPointF &position, int resizeE
     return QPointF(x, y);
 }
 
-QPointF CompositorWindow::getAnchoredPosition(const QPointF &anchorPosition, int resizeEdge, const QSize &windowSize)
+QPointF Window::getAnchoredPosition(const QPointF &anchorPosition, int resizeEdge, const QSize &windowSize)
 {
     return anchorPosition - getAnchorPosition(QPointF(), resizeEdge, windowSize);
 }
 
-void CompositorWindow::paintGL()
+void Window::paintGL()
 {
     m_compositor->startRender();
     QOpenGLFunctions *functions = context()->functions();
@@ -117,7 +117,7 @@ void CompositorWindow::paintGL()
     functions->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     GLenum currentTarget = GL_TEXTURE_2D;
-    Q_FOREACH (WindowCompositorView *view, m_compositor->views()) {
+    Q_FOREACH (View *view, m_compositor->views()) {
         if (view->isCursor())
             continue;
         GLenum target;
@@ -151,10 +151,10 @@ void CompositorWindow::paintGL()
     m_compositor->endRender();
 }
 
-WindowCompositorView *CompositorWindow::viewAt(const QPointF &point)
+View *Window::viewAt(const QPointF &point)
 {
-    WindowCompositorView *ret = 0;
-    Q_FOREACH (WindowCompositorView *view, m_compositor->views()) {
+    View *ret = 0;
+    Q_FOREACH (View *view, m_compositor->views()) {
         if (view == m_dragIconView)
             continue;
         QPointF topLeft = view->position();
@@ -166,12 +166,12 @@ WindowCompositorView *CompositorWindow::viewAt(const QPointF &point)
     return ret;
 }
 
-void CompositorWindow::startMove()
+void Window::startMove()
 {
     m_grabState = MoveGrab;
 }
 
-void CompositorWindow::startResize(int edge, bool anchored)
+void Window::startResize(int edge, bool anchored)
 {
     m_initialSize = m_mouseView->windowSize();
     m_grabState = ResizeGrab;
@@ -180,14 +180,14 @@ void CompositorWindow::startResize(int edge, bool anchored)
     m_resizeAnchorPosition = getAnchorPosition(m_mouseView->position(), edge, m_mouseView->surface()->size());
 }
 
-void CompositorWindow::startDrag(WindowCompositorView *dragIcon)
+void Window::startDrag(View *dragIcon)
 {
     m_grabState = DragGrab;
     m_dragIconView = dragIcon;
     m_compositor->raise(dragIcon);
 }
 
-void CompositorWindow::mousePressEvent(QMouseEvent *e)
+void Window::mousePressEvent(QMouseEvent *e)
 {
     if (mouseGrab())
         return;
@@ -210,13 +210,13 @@ void CompositorWindow::mousePressEvent(QMouseEvent *e)
     sendMouseEvent(e, m_mouseView);
 }
 
-void CompositorWindow::mouseReleaseEvent(QMouseEvent *e)
+void Window::mouseReleaseEvent(QMouseEvent *e)
 {
     if (!mouseGrab())
         sendMouseEvent(e, m_mouseView);
     if (e->buttons() == Qt::NoButton) {
         if (m_grabState == DragGrab) {
-            WindowCompositorView *view = viewAt(e->localPos());
+            View *view = viewAt(e->localPos());
             m_compositor->handleDrag(view, e);
         }
         m_mouseView = 0;
@@ -224,11 +224,11 @@ void CompositorWindow::mouseReleaseEvent(QMouseEvent *e)
     }
 }
 
-void CompositorWindow::mouseMoveEvent(QMouseEvent *e)
+void Window::mouseMoveEvent(QMouseEvent *e)
 {
     switch (m_grabState) {
     case NoGrab: {
-        WindowCompositorView *view = m_mouseView ? m_mouseView.data() : viewAt(e->localPos());
+        View *view = m_mouseView ? m_mouseView.data() : viewAt(e->localPos());
         sendMouseEvent(e, view);
         if (!view)
             setCursor(Qt::ArrowCursor);
@@ -245,7 +245,7 @@ void CompositorWindow::mouseMoveEvent(QMouseEvent *e)
     }
         break;
     case DragGrab: {
-        WindowCompositorView *view = viewAt(e->localPos());
+        View *view = viewAt(e->localPos());
         m_compositor->handleDrag(view, e);
         if (m_dragIconView) {
             m_dragIconView->setPosition(e->localPos() + m_dragIconView->offset());
@@ -256,7 +256,7 @@ void CompositorWindow::mouseMoveEvent(QMouseEvent *e)
     }
 }
 
-void CompositorWindow::sendMouseEvent(QMouseEvent *e, WindowCompositorView *target)
+void Window::sendMouseEvent(QMouseEvent *e, View *target)
 {
     if (!target)
         return;
@@ -266,12 +266,12 @@ void CompositorWindow::sendMouseEvent(QMouseEvent *e, WindowCompositorView *targ
     m_compositor->handleMouseEvent(target, &viewEvent);
 }
 
-void CompositorWindow::keyPressEvent(QKeyEvent *e)
+void Window::keyPressEvent(QKeyEvent *e)
 {
     m_compositor->defaultInputDevice()->sendKeyPressEvent(e->nativeScanCode());
 }
 
-void CompositorWindow::keyReleaseEvent(QKeyEvent *e)
+void Window::keyReleaseEvent(QKeyEvent *e)
 {
     m_compositor->defaultInputDevice()->sendKeyReleaseEvent(e->nativeScanCode());
 }
diff --git a/examples/wayland/qwindow-compositor/compositorwindow.h b/examples/wayland/qwindow-compositor/window.h
index 3e6a02e44..53c85a6ef 100644
--- a/examples/wayland/qwindow-compositor/compositorwindow.h
+++ b/examples/wayland/qwindow-compositor/window.h
@@ -47,16 +47,16 @@
 
 QT_BEGIN_NAMESPACE
 
-class WindowCompositor;
-class WindowCompositorView;
+class Compositor;
+class View;
 class QOpenGLTexture;
 
-class CompositorWindow : public QOpenGLWindow
+class Window : public QOpenGLWindow
 {
 public:
-    CompositorWindow();
+    Window();
 
-    void setCompositor(WindowCompositor *comp);
+    void setCompositor(Compositor *comp);
 
 protected:
     void initializeGL() Q_DECL_OVERRIDE;
@@ -72,23 +72,23 @@ protected:
 private slots:
     void startMove();
     void startResize(int edge, bool anchored);
-    void startDrag(WindowCompositorView *dragIcon);
+    void startDrag(View *dragIcon);
 
 private:
     enum GrabState { NoGrab, MoveGrab, ResizeGrab, DragGrab };
 
-    WindowCompositorView *viewAt(const QPointF &point);
+    View *viewAt(const QPointF &point);
     bool mouseGrab() const { return m_grabState != NoGrab ;}
     void drawBackground();
-    void sendMouseEvent(QMouseEvent *e, WindowCompositorView *target);
+    void sendMouseEvent(QMouseEvent *e, View *target);
     static QPointF getAnchoredPosition(const QPointF &anchorPosition, int resizeEdge, const QSize &windowSize);
     static QPointF getAnchorPosition(const QPointF &position, int resizeEdge, const QSize &windowSize);
 
     QOpenGLTextureBlitter m_textureBlitter;
     QSize m_backgroundImageSize;
     QOpenGLTexture *m_backgroundTexture;
-    WindowCompositor *m_compositor;
-    QPointer<WindowCompositorView> m_mouseView;
+    Compositor *m_compositor;
+    QPointer<View> m_mouseView;
     GrabState m_grabState;
     QSize m_initialSize;
     int m_resizeEdge;
@@ -96,7 +96,7 @@ private:
     QPointF m_resizeAnchorPosition;
     QPointF m_mouseOffset;
     QPointF m_initialMousePos;
-    WindowCompositorView *m_dragIconView;
+    View *m_dragIconView;
 };
 
 QT_END_NAMESPACE
diff --git a/src/client/global/qwaylandclientextension.h b/src/client/global/qwaylandclientextension.h
index a39f32b7f..d1610c271 100644
--- a/src/client/global/qwaylandclientextension.h
+++ b/src/client/global/qwaylandclientextension.h
@@ -39,7 +39,9 @@
 
 #include <QObject>
 #include <QtWaylandClient/qwaylandclientexport.h>
-#include <QtWaylandClient/private/qwayland-wayland.h>
+
+struct wl_registry;
+
 QT_BEGIN_NAMESPACE
 
 namespace QtWaylandClient {
diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp
index 9ed76d2ce..7b3ff7bbb 100644
--- a/src/client/qwaylanddisplay.cpp
+++ b/src/client/qwaylanddisplay.cpp
@@ -137,6 +137,8 @@ QWaylandDisplay::QWaylandDisplay(QWaylandIntegration *waylandIntegration)
     , mLastInputSerial(0)
     , mLastInputDevice(0)
     , mLastInputWindow(0)
+    , mLastKeyboardFocus(Q_NULLPTR)
+    , mSyncCallback(Q_NULLPTR)
 {
     qRegisterMetaType<uint32_t>("uint32_t");
 
@@ -393,6 +395,73 @@ void QWaylandDisplay::setLastInputDevice(QWaylandInputDevice *device, uint32_t s
     mLastInputWindow = win;
 }
 
+bool QWaylandDisplay::shellManagesActiveState() const
+{
+    //TODO: This should be part of a shell interface used by the shell protocol implementations
+    return mShellXdg;
+}
+
+void QWaylandDisplay::handleWindowActivated(QWaylandWindow *window)
+{
+    if (mActiveWindows.contains(window))
+        return;
+
+    mActiveWindows.append(window);
+    requestWaylandSync();
+}
+
+void QWaylandDisplay::handleWindowDeactivated(QWaylandWindow *window)
+{
+    Q_ASSERT(!mActiveWindows.empty());
+
+    if (mActiveWindows.last() == window)
+        requestWaylandSync();
+
+    mActiveWindows.removeOne(window);
+}
+
+void QWaylandDisplay::handleKeyboardFocusChanged(QWaylandInputDevice *inputDevice)
+{
+    QWaylandWindow *keyboardFocus = inputDevice->keyboardFocus();
+
+    if (!shellManagesActiveState() && mLastKeyboardFocus != keyboardFocus) {
+        if (keyboardFocus)
+            handleWindowActivated(keyboardFocus);
+        if (mLastKeyboardFocus)
+            handleWindowDeactivated(mLastKeyboardFocus);
+    }
+    mLastKeyboardFocus = inputDevice->keyboardFocus();
+}
+
+void QWaylandDisplay::handleWaylandSync()
+{
+    // This callback is used to set the window activation because we may get an activate/deactivate
+    // pair, and the latter one would be lost in the QWindowSystemInterface queue, if we issue the
+    // handleWindowActivated() calls immediately.
+    QWindow *activeWindow = mActiveWindows.empty() ? Q_NULLPTR : mActiveWindows.last()->window();
+    if (activeWindow != QGuiApplication::focusWindow())
+        QWindowSystemInterface::handleWindowActivated(activeWindow);
+}
+
+const wl_callback_listener QWaylandDisplay::syncCallbackListener = {
+    [](void *data, struct wl_callback *callback, uint32_t time){
+        Q_UNUSED(time);
+        wl_callback_destroy(callback);
+        QWaylandDisplay *display = static_cast<QWaylandDisplay *>(data);
+        display->mSyncCallback = Q_NULLPTR;
+        display->handleWaylandSync();
+    }
+};
+
+void QWaylandDisplay::requestWaylandSync()
+{
+    if (mSyncCallback)
+        return;
+
+    mSyncCallback = wl_display_sync(mDisplay);
+    wl_callback_add_listener(mSyncCallback, &syncCallbackListener, this);
+}
+
 }
 
 QT_END_NAMESPACE
diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h
index 1c0b46bfb..b040d69a0 100644
--- a/src/client/qwaylanddisplay_p.h
+++ b/src/client/qwaylanddisplay_p.h
@@ -54,6 +54,7 @@
 #include <QtCore/QObject>
 #include <QtCore/QRect>
 #include <QtCore/QPointer>
+#include <QtCore/QVector>
 
 #include <QtCore/QWaitCondition>
 
@@ -174,6 +175,11 @@ public:
     QWaylandWindow *lastInputWindow() const;
     void setLastInputDevice(QWaylandInputDevice *device, uint32_t serial, QWaylandWindow *window);
 
+    bool shellManagesActiveState() const;
+    void handleWindowActivated(QWaylandWindow *window);
+    void handleWindowDeactivated(QWaylandWindow *window);
+    void handleKeyboardFocusChanged(QWaylandInputDevice *inputDevice);
+
 public slots:
     void blockingReadEvents();
     void flushRequests();
@@ -183,6 +189,9 @@ private:
     void exitWithError();
     void checkError() const;
 
+    void handleWaylandSync();
+    void requestWaylandSync();
+
     struct Listener {
         RegistryListener listener;
         void *data;
@@ -213,6 +222,10 @@ private:
     uint32_t mLastInputSerial;
     QWaylandInputDevice *mLastInputDevice;
     QPointer<QWaylandWindow> mLastInputWindow;
+    QWaylandWindow *mLastKeyboardFocus;
+    QVector<QWaylandWindow *> mActiveWindows;
+    struct wl_callback *mSyncCallback;
+    static const wl_callback_listener syncCallbackListener;
 
     void registry_global(uint32_t id, const QString &interface, uint32_t version) Q_DECL_OVERRIDE;
     void registry_global_remove(uint32_t id) Q_DECL_OVERRIDE;
diff --git a/src/client/qwaylandinputcontext.cpp b/src/client/qwaylandinputcontext.cpp
index 509965d2f..5a58d6d75 100644
--- a/src/client/qwaylandinputcontext.cpp
+++ b/src/client/qwaylandinputcontext.cpp
@@ -335,8 +335,9 @@ void QWaylandTextInput::zwp_text_input_v2_keysym(uint32_t time, uint32_t sym, ui
     Qt::KeyboardModifiers qtModifiers = modifiersToQtModifiers(modifiers);
 
     QEvent::Type type = QWaylandXkb::toQtEventType(state);
-    const QString &text = QWaylandXkb::textFromKeysym(sym, qtModifiers);
-    int qtkey = QWaylandXkb::keysymToQtKey(sym, qtModifiers, text);
+    QString text;
+    int qtkey;
+    std::tie(qtkey, text) = QWaylandXkb::keysymToQtKey(sym, qtModifiers);
 
     QWindowSystemInterface::handleKeyEvent(QGuiApplication::focusWindow(),
                                            time, type, qtkey, qtModifiers, text);
diff --git a/src/client/qwaylandinputdevice.cpp b/src/client/qwaylandinputdevice.cpp
index 613d517a3..f490f07ff 100644
--- a/src/client/qwaylandinputdevice.cpp
+++ b/src/client/qwaylandinputdevice.cpp
@@ -78,7 +78,6 @@ QWaylandInputDevice::Keyboard::Keyboard(QWaylandInputDevice *p)
     , mXkbMap(0)
     , mXkbState(0)
 #endif
-    , mFocusCallback(0)
     , mNativeModifiers(0)
 {
     connect(&mRepeatTimer, SIGNAL(timeout()), this, SLOT(repeatKey()));
@@ -131,8 +130,6 @@ QWaylandInputDevice::Keyboard::~Keyboard()
 #endif
     if (mFocus)
         QWindowSystemInterface::handleWindowActivated(0);
-    if (mFocusCallback)
-        wl_callback_destroy(mFocusCallback);
     if (mParent->mVersion >= 3)
         wl_keyboard_release(object());
     else
@@ -614,10 +611,7 @@ void QWaylandInputDevice::Keyboard::keyboard_enter(uint32_t time, struct wl_surf
     QWaylandWindow *window = QWaylandWindow::fromWlSurface(surface);
     mFocus = window;
 
-    if (!mFocusCallback) {
-        mFocusCallback = wl_display_sync(mParent->mDisplay);
-        wl_callback_add_listener(mFocusCallback, &QWaylandInputDevice::Keyboard::callback, this);
-    }
+    mParent->mQDisplay->handleKeyboardFocusChanged(mParent);
 }
 
 void QWaylandInputDevice::Keyboard::keyboard_leave(uint32_t time, struct wl_surface *surface)
@@ -632,31 +626,9 @@ void QWaylandInputDevice::Keyboard::keyboard_leave(uint32_t time, struct wl_surf
 
     mFocus = NULL;
 
-    // Use a callback to set the focus because we may get a leave/enter pair, and
-    // the latter one would be lost in the QWindowSystemInterface queue, if
-    // we issue the handleWindowActivated() calls immediately.
-    if (!mFocusCallback) {
-        mFocusCallback = wl_display_sync(mParent->mDisplay);
-        wl_callback_add_listener(mFocusCallback, &QWaylandInputDevice::Keyboard::callback, this);
-    }
-    mRepeatTimer.stop();
-}
-
-const wl_callback_listener QWaylandInputDevice::Keyboard::callback = {
-    QWaylandInputDevice::Keyboard::focusCallback
-};
+    mParent->mQDisplay->handleKeyboardFocusChanged(mParent);
 
-void QWaylandInputDevice::Keyboard::focusCallback(void *data, struct wl_callback *callback, uint32_t time)
-{
-    Q_UNUSED(time);
-    Q_UNUSED(callback);
-    QWaylandInputDevice::Keyboard *self = static_cast<QWaylandInputDevice::Keyboard *>(data);
-    if (self->mFocusCallback) {
-        wl_callback_destroy(self->mFocusCallback);
-        self->mFocusCallback = 0;
-    }
-
-    QWindowSystemInterface::handleWindowActivated(self->mFocus ? self->mFocus->window() : 0);
+    mRepeatTimer.stop();
 }
 
 static void sendKey(QWindow *tlw, ulong timestamp, QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
@@ -707,8 +679,7 @@ void QWaylandInputDevice::Keyboard::keyboard_key(uint32_t serial, uint32_t time,
 
     Qt::KeyboardModifiers modifiers = mParent->modifiers();
 
-    text = QWaylandXkb::textFromKeysym(sym, modifiers);
-    qtkey = QWaylandXkb::keysymToQtKey(sym, modifiers, text);
+    std::tie(qtkey, text) = QWaylandXkb::keysymToQtKey(sym, modifiers);
 
     sendKey(window->window(), time, type, qtkey, modifiers, code, sym, mNativeModifiers, text);
 #else
diff --git a/src/client/qwaylandinputdevice_p.h b/src/client/qwaylandinputdevice_p.h
index 3954328f1..ea685223d 100644
--- a/src/client/qwaylandinputdevice_p.h
+++ b/src/client/qwaylandinputdevice_p.h
@@ -197,7 +197,6 @@ public:
     xkb_keymap *mXkbMap;
     xkb_state *mXkbState;
 #endif
-    struct wl_callback *mFocusCallback;
     uint32_t mNativeModifiers;
 
     int mRepeatKey;
@@ -209,9 +208,6 @@ public:
 #endif
     QTimer mRepeatTimer;
 
-    static const wl_callback_listener callback;
-    static void focusCallback(void *data, struct wl_callback *callback, uint32_t time);
-
     Qt::KeyboardModifiers modifiers() const;
 
 private slots:
diff --git a/src/client/qwaylandshmbackingstore.cpp b/src/client/qwaylandshmbackingstore.cpp
index ea1fe7baa..13f823edf 100644
--- a/src/client/qwaylandshmbackingstore.cpp
+++ b/src/client/qwaylandshmbackingstore.cpp
@@ -308,29 +308,37 @@ void QWaylandShmBackingStore::updateDecorations()
     QPainter decorationPainter(entireSurface());
     decorationPainter.setCompositionMode(QPainter::CompositionMode_Source);
     QImage sourceImage = windowDecoration()->contentImage();
-    QRect target;
+
+    qreal dp = sourceImage.devicePixelRatio();
+    int dpWidth = int(sourceImage.width() / dp);
+    int dpHeight = int(sourceImage.height() / dp);
+    QMatrix sourceMatrix;
+    sourceMatrix.scale(dp, dp);
+    QRect target; // needs to be in device independent pixels
+
     //Top
     target.setX(0);
     target.setY(0);
-    target.setWidth(sourceImage.width());
+    target.setWidth(dpWidth);
     target.setHeight(windowDecorationMargins().top());
-    decorationPainter.drawImage(target, sourceImage, target);
+    decorationPainter.drawImage(target, sourceImage, sourceMatrix.mapRect(target));
 
     //Left
     target.setWidth(windowDecorationMargins().left());
-    target.setHeight(sourceImage.height());
-    decorationPainter.drawImage(target, sourceImage, target);
+    target.setHeight(dpHeight);
+    decorationPainter.drawImage(target, sourceImage, sourceMatrix.mapRect(target));
 
     //Right
-    target.setX(sourceImage.width() - windowDecorationMargins().right());
-    decorationPainter.drawImage(target, sourceImage, target);
+    target.setX(dpWidth - windowDecorationMargins().right());
+    target.setWidth(windowDecorationMargins().right());
+    decorationPainter.drawImage(target, sourceImage, sourceMatrix.mapRect(target));
 
     //Bottom
     target.setX(0);
-    target.setY(sourceImage.height() - windowDecorationMargins().bottom());
-    target.setWidth(sourceImage.width());
+    target.setY(dpHeight - windowDecorationMargins().bottom());
+    target.setWidth(dpWidth);
     target.setHeight(windowDecorationMargins().bottom());
-    decorationPainter.drawImage(target, sourceImage, target);
+    decorationPainter.drawImage(target, sourceImage, sourceMatrix.mapRect(target));
 }
 
 QWaylandAbstractDecoration *QWaylandShmBackingStore::windowDecoration() const
diff --git a/src/client/qwaylandxdgsurface.cpp b/src/client/qwaylandxdgsurface.cpp
index 69532b514..93263e0aa 100644
--- a/src/client/qwaylandxdgsurface.cpp
+++ b/src/client/qwaylandxdgsurface.cpp
@@ -58,6 +58,7 @@ QWaylandXdgSurface::QWaylandXdgSurface(struct ::xdg_surface *xdg_surface, QWayla
     , m_maximized(false)
     , m_minimized(false)
     , m_fullscreen(false)
+    , m_active(false)
     , m_extendedWindow(Q_NULLPTR)
 {
     if (window->display()->windowExtension())
@@ -66,6 +67,9 @@ QWaylandXdgSurface::QWaylandXdgSurface(struct ::xdg_surface *xdg_surface, QWayla
 
 QWaylandXdgSurface::~QWaylandXdgSurface()
 {
+    if (m_active)
+        window()->display()->handleWindowDeactivated(m_window);
+
     xdg_surface_destroy(object());
     delete m_extendedWindow;
 }
@@ -182,6 +186,7 @@ void QWaylandXdgSurface::xdg_surface_configure(int32_t width, int32_t height, st
     size_t numStates = states->size / sizeof(uint32_t);
     bool aboutToMaximize = false;
     bool aboutToFullScreen = false;
+    bool aboutToActivate = false;
 
     for (size_t i = 0; i < numStates; i++) {
         switch (state[i]) {
@@ -195,13 +200,21 @@ void QWaylandXdgSurface::xdg_surface_configure(int32_t width, int32_t height, st
             m_normalSize = QSize(width, height);
             break;
         case XDG_SURFACE_STATE_ACTIVATED:
-            // TODO: here about the missing window activation
+            aboutToActivate = true;
             break;
         default:
             break;
         }
     }
 
+    if (!m_active && aboutToActivate) {
+        m_active = true;
+        window()->display()->handleWindowActivated(m_window);
+    } else if (m_active && !aboutToActivate) {
+        m_active = false;
+        window()->display()->handleWindowDeactivated(m_window);
+    }
+
     if (!m_fullscreen && aboutToFullScreen) {
         if (!m_maximized)
             m_normalSize = m_window->window()->frameGeometry().size();
diff --git a/src/client/qwaylandxdgsurface_p.h b/src/client/qwaylandxdgsurface_p.h
index 24eb86519..e98aa41e9 100644
--- a/src/client/qwaylandxdgsurface_p.h
+++ b/src/client/qwaylandxdgsurface_p.h
@@ -112,6 +112,7 @@ private:
     bool m_maximized;
     bool m_minimized;
     bool m_fullscreen;
+    bool m_active;
     QSize m_normalSize;
     QMargins m_margins;
     QWaylandExtendedSurface *m_extendedWindow;
diff --git a/src/compositor/compositor_api/qwaylandcompositor.cpp b/src/compositor/compositor_api/qwaylandcompositor.cpp
index f92a8845b..a483a7564 100644
--- a/src/compositor/compositor_api/qwaylandcompositor.cpp
+++ b/src/compositor/compositor_api/qwaylandcompositor.cpp
@@ -110,10 +110,8 @@ public:
             Qt::KeyboardModifiers modifiers = QWaylandXkb::modifiers(keyb->xkbState());
 
             const xkb_keysym_t sym = xkb_state_key_get_one_sym(keyb->xkbState(), code);
-            uint utf32 = xkb_keysym_to_utf32(sym);
-            if (utf32)
-                text = QString::fromUcs4(&utf32, 1);
-            int qtkey = QWaylandXkb::keysymToQtKey(sym, modifiers, text);
+            int qtkey;
+            std::tie(qtkey, text) = QWaylandXkb::keysymToQtKey(sym, modifiers);
 
             ke->key = qtkey;
             ke->modifiers = modifiers;
diff --git a/src/compositor/doc/qtwaylandcompositor.qdocconf b/src/compositor/doc/qtwaylandcompositor.qdocconf
index 230978f07..3954cb22f 100644
--- a/src/compositor/doc/qtwaylandcompositor.qdocconf
+++ b/src/compositor/doc/qtwaylandcompositor.qdocconf
@@ -1,4 +1,4 @@
-include($QT_INSTALL_DOCS/global//qt-module-defaults.qdocconf)
+include($QT_INSTALL_DOCS/global/qt-module-defaults.qdocconf)
 
 project                                                     = QtWaylandCompositor
 description                                                 = Qt Wayland Compositor Reference Documentation
@@ -31,12 +31,15 @@ qhp.QtWaylandCompositor.subprojects.examples.sortPages      = true
 
 depends += qtqml qtquick qtdoc qtquickcontrols qmake qtgui
 
-exampledirs += ../../../examples/wayland/
-headerdirs += ../
-sourcedirs += ../
+exampledirs += ../../../examples/wayland
+headerdirs += ..
+sourcedirs += ..
 imagedirs  += images
 
-examplesinstallpath = waylandcompositor
+examplesinstallpath = wayland
+
+Cpp.ignoretokens         += Q_WAYLAND_COMPOSITOR_EXPORT
+Cpp.ignoredirectives     += Q_DECLARE_LOGGING_CATEGORY
 
 navigation.landingpage    = "Qt Wayland Compositor"
 navigation.qmltypespage   = "Qt Wayland Compositor QML Types"
diff --git a/src/compositor/extensions/qwaylandwlshell.h b/src/compositor/extensions/qwaylandwlshell.h
index 38d87a8c7..ce6ca895c 100644
--- a/src/compositor/extensions/qwaylandwlshell.h
+++ b/src/compositor/extensions/qwaylandwlshell.h
@@ -160,7 +160,7 @@ Q_SIGNALS:
     void setMaximized(QWaylandOutput *output);
 
 private:
-    void initialize();
+    void initialize() override;
 };
 
 QT_END_NAMESPACE
diff --git a/src/compositor/extensions/qwaylandxdgshell.h b/src/compositor/extensions/qwaylandxdgshell.h
index 263633dcc..af198989d 100644
--- a/src/compositor/extensions/qwaylandxdgshell.h
+++ b/src/compositor/extensions/qwaylandxdgshell.h
@@ -189,7 +189,7 @@ Q_SIGNALS:
     void ackConfigure(uint serial);
 
 private:
-    void initialize();
+    void initialize() override;
     QList<int> statesAsInts() const;
 
 private Q_SLOTS:
@@ -233,7 +233,7 @@ Q_SIGNALS:
     void parentSurfaceChanged();
 
 private:
-    void initialize();
+    void initialize() override;
 };
 
 QT_END_NAMESPACE
diff --git a/src/imports/compositor/qwaylandquickcompositorplugin.cpp b/src/imports/compositor/qwaylandquickcompositorplugin.cpp
index b93f9f169..0403f8d39 100644
--- a/src/imports/compositor/qwaylandquickcompositorplugin.cpp
+++ b/src/imports/compositor/qwaylandquickcompositorplugin.cpp
@@ -88,23 +88,6 @@ private:
 };
 
 
-/*!
-    \qmlmodule QtWayland.Compositor 1.0
-    \title Qt Wayland Compositor QML Types
-    \ingroup qmlmodules
-    \brief Provides QML types for creating Wayland compositors
-
-    This QML module contains types for creating Wayland compositors.
-
-    To use the types in this module, import the module with the following line:
-
-    \code
-    import QtWayland.Compositor 1.0
-    \endcode
-*/
-
-
-
 //![class decl]
 class QWaylandCompositorPlugin : public QQmlExtensionPlugin
 {
diff --git a/src/shared/qwaylandxkb.cpp b/src/shared/qwaylandxkb.cpp
index 499257009..2afdcce8a 100644
--- a/src/shared/qwaylandxkb.cpp
+++ b/src/shared/qwaylandxkb.cpp
@@ -293,8 +293,13 @@ static xkb_keysym_t toKeysymFromTable(uint32_t key)
     return 0;
 }
 
-int QWaylandXkb::keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers &modifiers, const QString &text)
+std::pair<int, QString> QWaylandXkb::keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers &modifiers)
 {
+    QString text;
+    uint utf32 = xkb_keysym_to_utf32(keysym);
+    if (utf32)
+        text = QString::fromUcs4(&utf32, 1);
+
     int code = 0;
 
     if (keysym >= XKB_KEY_F1 && keysym <= XKB_KEY_F35) {
@@ -316,7 +321,13 @@ int QWaylandXkb::keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers &modif
         code = lookupKeysym(keysym);
     }
 
-    return code;
+    // Map control + letter to proper text
+    if (utf32 >= 'A' && utf32 <= '~' && (modifiers & Qt::ControlModifier)) {
+        utf32 &= ~0x60;
+        text = QString::fromUcs4(&utf32, 1);
+    }
+
+    return { code, text };
 }
 
 Qt::KeyboardModifiers QWaylandXkb::modifiers(struct xkb_state *state)
@@ -342,22 +353,6 @@ QEvent::Type QWaylandXkb::toQtEventType(uint32_t state)
     return state != 0 ? QEvent::KeyPress : QEvent::KeyRelease;
 }
 
-QString QWaylandXkb::textFromKeysym(uint32_t keysym, Qt::KeyboardModifiers modifiers)
-{
-    uint utf32 = xkb_keysym_to_utf32(keysym);
-
-    // Map control + letter to proper text
-    if (utf32 >= 'A' && utf32 <= '~' && (modifiers & Qt::ControlModifier)) {
-        utf32 &= ~0x60;
-        return QString::fromUcs4(&utf32, 1);
-    }
-
-    if (utf32)
-        return QString::fromUcs4(&utf32, 1);
-
-    return QString();
-}
-
 QVector<xkb_keysym_t> QWaylandXkb::toKeysym(QKeyEvent *event)
 {
     QVector<xkb_keysym_t> keysyms;
diff --git a/src/shared/qwaylandxkb_p.h b/src/shared/qwaylandxkb_p.h
index 9b5c935a5..cdebf1b08 100644
--- a/src/shared/qwaylandxkb_p.h
+++ b/src/shared/qwaylandxkb_p.h
@@ -47,6 +47,8 @@
 #include <QEvent>
 #include <xkbcommon/xkbcommon.h>
 
+#include <utility>
+
 QT_BEGIN_NAMESPACE
 
 class QKeyEvent;
@@ -54,11 +56,10 @@ class QKeyEvent;
 class QWaylandXkb
 {
 public:
-    static int keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers &modifiers, const QString &text);
+    static std::pair<int, QString> keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers &modifiers);
     static Qt::KeyboardModifiers modifiers(struct xkb_state *state);
 
     static QEvent::Type toQtEventType(uint32_t state);
-    static QString textFromKeysym(uint32_t keysym, Qt::KeyboardModifiers modifiers);
     static QVector<xkb_keysym_t> toKeysym(QKeyEvent *event);
 };