Example cleanup

Use sane class names and file names, just like we do in minimal-cpp.

Change-Id: I17ef83711040a5507425721e695d64f43411fc4b
Reviewed-by: Johan Helsing <johan.helsing@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

6 files changed, 145 insertions, 145 deletions

diff --git a/examples/wayland/qwindow-compositor/windowcompositor.cpp b/examples/wayland/qwindow-compositor/compositor.cpp
index b2176f39b..065a6bfae 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->requestMaximized(output()->geometry().size());
 
@@ -110,12 +110,12 @@ void WindowCompositorView::onXdgSetMaximized()
     setPosition(QPoint(0, 0));
 }
 
-void WindowCompositorView::onXdgUnsetMaximized()
+void View::onXdgUnsetMaximized()
 {
     m_xdgSurface->requestUnMaximized();
 }
 
-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, 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 8b5180a00..9a01e2831 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