Qt-ify the QtCompositor module

Currently the QtCompositor library and API do not follow the Qt API
naming conventions.  This commit intends to fix these inconsistencies.

filenames start with q
headers containing private API's end in _p
public API classes begin with Q
use the qt namespace macros where necessary

Wayland namespace is now QtWayland
wayland_wrapper classes are now private API's

It's important to make these changes not just for stylistic reasons, but
also because when qmake builds the module in checks for these
conventions to determine how to deploy the include files.

Change-Id: I8bfadeceda92a0f52cb73c704551da75540e7587
Reviewed-by: Paul Olav Tvete <paul.tvete@digia.com>

65 files changed, 942 insertions, 712 deletions

diff --git a/src/compositor/compositor.pri b/src/compositor/compositor.pri
deleted file mode 100644
index 595bbf7c7..000000000
--- a/src/compositor/compositor.pri
+++ /dev/null
@@ -1,15 +0,0 @@
-CONFIG += link_pkgconfig
-
-DEFINES += QT_WAYLAND_WINDOWMANAGER_SUPPORT
-
-!contains(QT_CONFIG, no-pkg-config) {
-    PKGCONFIG += wayland-server
-} else {
-    LIBS += -lwayland-server
-}
-
-include ($$PWD/global/global.pri)
-include ($$PWD/wayland_wrapper/wayland_wrapper.pri)
-include ($$PWD/hardware_integration/hardware_integration.pri)
-include ($$PWD/compositor_api/compositor_api.pri)
-include ($$PWD/windowmanagerprotocol/windowmanagerprotocol.pri)
diff --git a/src/compositor/compositor.pro b/src/compositor/compositor.pro
index 5ba6bc111..8a2fa01e3 100644
--- a/src/compositor/compositor.pro
+++ b/src/compositor/compositor.pro
@@ -5,5 +5,24 @@ contains(QT_CONFIG, opengl):MODULE_DEFINES = QT_COMPOSITOR_WAYLAND_GL
 
 load(qt_module)
 
-include(compositor.pri)
+CONFIG += link_pkgconfig
+
+DEFINES += QT_WAYLAND_WINDOWMANAGER_SUPPORT
+
+!contains(QT_CONFIG, no-pkg-config) {
+    PKGCONFIG += wayland-server
+} else {
+    LIBS += -lwayland-server
+}
+
+INCLUDEPATH += ../shared
+HEADERS += ../shared/qwaylandmimehelper.h
+SOURCES += ../shared/qwaylandmimehelper.cpp
+
+include ($$PWD/global/global.pri)
+include ($$PWD/wayland_wrapper/wayland_wrapper.pri)
+include ($$PWD/hardware_integration/hardware_integration.pri)
+include ($$PWD/compositor_api/compositor_api.pri)
+include ($$PWD/windowmanagerprotocol/windowmanagerprotocol.pri)
+
 
diff --git a/src/compositor/compositor_api/compositor_api.pri b/src/compositor/compositor_api/compositor_api.pri
index 2e98c7757..f0bbe7648 100644
--- a/src/compositor/compositor_api/compositor_api.pri
+++ b/src/compositor/compositor_api/compositor_api.pri
@@ -1,29 +1,30 @@
-INCLUDEPATH += $$PWD
+INCLUDEPATH += compositor_api
 
 HEADERS += \
-    $$PWD/waylandcompositor.h \
-    $$PWD/waylandsurface.h \
-    $$PWD/waylandinput.h
+    compositor_api/qwaylandcompositor.h \
+    compositor_api/qwaylandsurface.h \
+    compositor_api/qwaylandinput.h
 
 SOURCES += \
-    $$PWD/waylandcompositor.cpp \
-    $$PWD/waylandsurface.cpp \
-    $$PWD/waylandinput.cpp
+    compositor_api/qwaylandcompositor.cpp \
+    compositor_api/qwaylandsurface.cpp \
+    compositor_api/qwaylandinput.cpp
 
 QT += core-private
 
 qtHaveModule(quick) {
-    SOURCES += $$PWD/waylandsurfaceitem.cpp \
-            $$PWD/waylandsurfacenode.cpp \
-            $$PWD/waylandsurfacetexturematerial.cpp
+    SOURCES += \
+        compositor_api/qwaylandsurfaceitem.cpp \
+        compositor_api/qwaylandsurfacenode.cpp \
+        compositor_api/qwaylandsurfacetexturematerial.cpp
 
-    HEADERS += $$PWD/waylandsurfaceitem.h \
-            $$PWD/waylandsurfacenode.h \
-            $$PWD/waylandsurfacetexturematerial.h
+    HEADERS += \
+        compositor_api/qwaylandsurfaceitem.h \
+        compositor_api/qwaylandsurfacenode_p.h \
+        compositor_api/qwaylandsurfacetexturematerial_p.h
 
     DEFINES += QT_COMPOSITOR_QUICK
 
     QT += qml quick
     QT += quick-private gui-private
 }
-
diff --git a/src/compositor/compositor_api/waylandcompositor.cpp b/src/compositor/compositor_api/qwaylandcompositor.cpp
index 38c404745..f742a8dea 100644
--- a/src/compositor/compositor_api/waylandcompositor.cpp
+++ b/src/compositor/compositor_api/qwaylandcompositor.cpp
@@ -38,13 +38,13 @@
 **
 ****************************************************************************/
 
-#include "waylandcompositor.h"
+#include "qwaylandcompositor.h"
 
-#include "waylandinput.h"
+#include "qwaylandinput.h"
 
-#include "wayland_wrapper/wlcompositor.h"
-#include "wayland_wrapper/wlsurface.h"
-#include "wayland_wrapper/wlinputdevice.h"
+#include "wayland_wrapper/qwlcompositor_p.h"
+#include "wayland_wrapper/qwlsurface_p.h"
+#include "wayland_wrapper/qwlinputdevice_p.h"
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QStringList>
@@ -54,10 +54,12 @@
 #include <QDebug>
 
 #ifdef QT_COMPOSITOR_QUICK
-#include "waylandsurfaceitem.h"
+#include "qwaylandsurfaceitem.h"
 #endif
 
-WaylandCompositor::WaylandCompositor(QWindow *window, const char *socketName)
+QT_BEGIN_NAMESPACE
+
+QWaylandCompositor::QWaylandCompositor(QWindow *window, const char *socketName)
     : m_compositor(0)
     , m_toplevel_window(window)
     , m_socket_name(socketName)
@@ -68,10 +70,10 @@ WaylandCompositor::WaylandCompositor(QWindow *window, const char *socketName)
     if (socketArg != -1 && socketArg + 1 < arguments.size())
         m_socket_name = arguments.at(socketArg + 1).toLocal8Bit();
 
-    m_compositor = new Wayland::Compositor(this);
+    m_compositor = new QtWayland::Compositor(this);
 #ifdef QT_COMPOSITOR_QUICK
-    qmlRegisterType<WaylandSurfaceItem>("WaylandCompositor", 1, 0, "WaylandSurfaceItem");
-    qmlRegisterType<WaylandSurface>("WaylandCompositor", 1, 0, "WaylandSurface");
+    qmlRegisterType<QWaylandSurfaceItem>("WaylandCompositor", 1, 0, "WaylandSurfaceItem");
+    qmlRegisterType<QWaylandSurface>("WaylandCompositor", 1, 0, "WaylandSurface");
 #else
     qRegisterMetaType<WaylandSurface*>("WaylandSurface*");
 #endif
@@ -80,38 +82,38 @@ WaylandCompositor::WaylandCompositor(QWindow *window, const char *socketName)
     m_compositor->initializeDefaultInputDevice();
 }
 
-WaylandCompositor::~WaylandCompositor()
+QWaylandCompositor::~QWaylandCompositor()
 {
     delete m_compositor;
 }
 
-struct wl_display *WaylandCompositor::waylandDisplay() const
+struct wl_display *QWaylandCompositor::waylandDisplay() const
 {
     return m_compositor->wl_display();
 }
-void WaylandCompositor::frameFinished(WaylandSurface *surface)
+void QWaylandCompositor::frameFinished(QWaylandSurface *surface)
 {
-    Wayland::Surface *surfaceImpl = surface? surface->handle():0;
+    QtWayland::Surface *surfaceImpl = surface? surface->handle():0;
     m_compositor->frameFinished(surfaceImpl);
 }
 
-void WaylandCompositor::destroyClientForSurface(WaylandSurface *surface)
+void QWaylandCompositor::destroyClientForSurface(QWaylandSurface *surface)
 {
     destroyClient(surface->client());
 }
 
-void WaylandCompositor::destroyClient(WaylandClient *client)
+void QWaylandCompositor::destroyClient(WaylandClient *client)
 {
     m_compositor->destroyClient(client);
 }
 
-QList<WaylandSurface *> WaylandCompositor::surfacesForClient(WaylandClient* c) const
+QList<QWaylandSurface *> QWaylandCompositor::surfacesForClient(WaylandClient* c) const
 {
     wl_client *client = static_cast<wl_client *>(c);
 
-    QList<Wayland::Surface *> surfaces = m_compositor->surfaces();
+    QList<QtWayland::Surface *> surfaces = m_compositor->surfaces();
 
-    QList<WaylandSurface *> result;
+    QList<QWaylandSurface *> result;
 
     for (int i = 0; i < surfaces.count(); ++i) {
         if (surfaces.at(i)->base()->resource.client == client) {
@@ -122,23 +124,23 @@ QList<WaylandSurface *> WaylandCompositor::surfacesForClient(WaylandClient* c) c
     return result;
 }
 
-void WaylandCompositor::setDirectRenderSurface(WaylandSurface *surface, QOpenGLContext *context)
+void QWaylandCompositor::setDirectRenderSurface(QWaylandSurface *surface, QOpenGLContext *context)
 {
     m_compositor->setDirectRenderSurface(surface ? surface->handle() : 0, context);
 }
 
-WaylandSurface *WaylandCompositor::directRenderSurface() const
+QWaylandSurface *QWaylandCompositor::directRenderSurface() const
 {
-    Wayland::Surface *surf = m_compositor->directRenderSurface();
+    QtWayland::Surface *surf = m_compositor->directRenderSurface();
     return surf ? surf->waylandSurface() : 0;
 }
 
-QWindow * WaylandCompositor::window() const
+QWindow * QWaylandCompositor::window() const
 {
     return m_toplevel_window;
 }
 
-void WaylandCompositor::surfaceAboutToBeDestroyed(WaylandSurface *surface)
+void QWaylandCompositor::surfaceAboutToBeDestroyed(QWaylandSurface *surface)
 {
     Q_UNUSED(surface);
 }
@@ -148,18 +150,18 @@ void WaylandCompositor::surfaceAboutToBeDestroyed(WaylandSurface *surface)
 
     The default implementation simply forwards the request to QDesktopServices::openUrl().
 */
-void WaylandCompositor::openUrl(WaylandClient *client, const QUrl &url)
+void QWaylandCompositor::openUrl(WaylandClient *client, const QUrl &url)
 {
     Q_UNUSED(client);
     QDesktopServices::openUrl(url);
 }
 
-Wayland::Compositor * WaylandCompositor::handle() const
+QtWayland::Compositor * QWaylandCompositor::handle() const
 {
     return m_compositor;
 }
 
-void WaylandCompositor::setRetainedSelectionEnabled(bool enable)
+void QWaylandCompositor::setRetainedSelectionEnabled(bool enable)
 {
     if (enable)
         m_compositor->setRetainedSelectionWatcher(retainedSelectionChanged, this);
@@ -167,27 +169,27 @@ void WaylandCompositor::setRetainedSelectionEnabled(bool enable)
         m_compositor->setRetainedSelectionWatcher(0, 0);
 }
 
-void WaylandCompositor::retainedSelectionChanged(QMimeData *mimeData, void *param)
+void QWaylandCompositor::retainedSelectionChanged(QMimeData *mimeData, void *param)
 {
-    WaylandCompositor *self = static_cast<WaylandCompositor *>(param);
+    QWaylandCompositor *self = static_cast<QWaylandCompositor *>(param);
     self->retainedSelectionReceived(mimeData);
 }
 
-void WaylandCompositor::retainedSelectionReceived(QMimeData *)
+void QWaylandCompositor::retainedSelectionReceived(QMimeData *)
 {
 }
 
-void WaylandCompositor::overrideSelection(QMimeData *data)
+void QWaylandCompositor::overrideSelection(QMimeData *data)
 {
     m_compositor->overrideSelection(data);
 }
 
-void WaylandCompositor::setClientFullScreenHint(bool value)
+void QWaylandCompositor::setClientFullScreenHint(bool value)
 {
     m_compositor->setClientFullScreenHint(value);
 }
 
-const char *WaylandCompositor::socketName() const
+const char *QWaylandCompositor::socketName() const
 {
     if (m_socket_name.isEmpty())
         return 0;
@@ -197,53 +199,53 @@ const char *WaylandCompositor::socketName() const
 /*!
   Set the screen orientation based on accelerometer data or similar.
 */
-void WaylandCompositor::setScreenOrientation(Qt::ScreenOrientation orientation)
+void QWaylandCompositor::setScreenOrientation(Qt::ScreenOrientation orientation)
 {
     m_compositor->setScreenOrientation(orientation);
 }
 
-void WaylandCompositor::setOutputGeometry(const QRect &geometry)
+void QWaylandCompositor::setOutputGeometry(const QRect &geometry)
 {
     m_compositor->setOutputGeometry(geometry);
 }
 
-QRect WaylandCompositor::outputGeometry() const
+QRect QWaylandCompositor::outputGeometry() const
 {
     return m_compositor->outputGeometry();
 }
 
-void WaylandCompositor::setOutputRefreshRate(int rate)
+void QWaylandCompositor::setOutputRefreshRate(int rate)
 {
     m_compositor->setOutputRefreshRate(rate);
 }
 
-int WaylandCompositor::outputRefreshRate() const
+int QWaylandCompositor::outputRefreshRate() const
 {
     return m_compositor->outputRefreshRate();
 }
 
-WaylandInputDevice *WaylandCompositor::defaultInputDevice() const
+QWaylandInputDevice *QWaylandCompositor::defaultInputDevice() const
 {
     return m_compositor->defaultInputDevice()->handle();
 }
 
-bool WaylandCompositor::isDragging() const
+bool QWaylandCompositor::isDragging() const
 {
     return m_compositor->isDragging();
 }
 
-void WaylandCompositor::sendDragMoveEvent(const QPoint &global, const QPoint &local,
-                                          WaylandSurface *surface)
+void QWaylandCompositor::sendDragMoveEvent(const QPoint &global, const QPoint &local,
+                                          QWaylandSurface *surface)
 {
     m_compositor->sendDragMoveEvent(global, local, surface ? surface->handle() : 0);
 }
 
-void WaylandCompositor::sendDragEndEvent()
+void QWaylandCompositor::sendDragEndEvent()
 {
     m_compositor->sendDragEndEvent();
 }
 
-void WaylandCompositor::setCursorSurface(WaylandSurface *surface, int hotspotX, int hotspotY)
+void QWaylandCompositor::setCursorSurface(QWaylandSurface *surface, int hotspotX, int hotspotY)
 {
     Q_UNUSED(surface);
     Q_UNUSED(hotspotX);
@@ -251,17 +253,19 @@ void WaylandCompositor::setCursorSurface(WaylandSurface *surface, int hotspotX,
     qDebug() << "changeCursor" << surface->size() << hotspotX << hotspotY;
 }
 
-void WaylandCompositor::enableSubSurfaceExtension()
+void QWaylandCompositor::enableSubSurfaceExtension()
 {
     m_compositor->enableSubSurfaceExtension();
 }
 
-void WaylandCompositor::enableTouchExtension()
+void QWaylandCompositor::enableTouchExtension()
 {
     // nothing to do here
 }
 
-void WaylandCompositor::configureTouchExtension(TouchExtensionFlags flags)
+void QWaylandCompositor::configureTouchExtension(TouchExtensionFlags flags)
 {
     m_compositor->configureTouchExtension(flags);
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandcompositor.h b/src/compositor/compositor_api/qwaylandcompositor.h
index 3df737d19..0f258617e 100644
--- a/src/compositor/compositor_api/waylandcompositor.h
+++ b/src/compositor/compositor_api/qwaylandcompositor.h
@@ -38,52 +38,54 @@
 **
 ****************************************************************************/
 
-#ifndef QTCOMP_H
-#define QTCOMP_H
+#ifndef QWAYLANDCOMPOSITOR_H
+#define QWAYLANDCOMPOSITOR_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
 #include <QObject>
 #include <QImage>
 #include <QRect>
 
+QT_BEGIN_NAMESPACE
+
 class QMimeData;
 class QUrl;
 class QOpenGLContext;
-class WaylandSurface;
-class WaylandInputDevice;
+class QWaylandSurface;
+class QWaylandInputDevice;
 
-namespace Wayland
+namespace QtWayland
 {
     class Compositor;
 }
 
-class Q_COMPOSITOR_EXPORT WaylandCompositor
+class Q_COMPOSITOR_EXPORT QWaylandCompositor
 {
 public:
-    WaylandCompositor(QWindow *window = 0, const char *socketName = 0);
-    virtual ~WaylandCompositor();
+    QWaylandCompositor(QWindow *window = 0, const char *socketName = 0);
+    virtual ~QWaylandCompositor();
 
     struct wl_display *waylandDisplay() const;
 
-    void frameFinished(WaylandSurface *surface = 0);
+    void frameFinished(QWaylandSurface *surface = 0);
 
-    void destroyClientForSurface(WaylandSurface *surface);
+    void destroyClientForSurface(QWaylandSurface *surface);
     void destroyClient(WaylandClient *client);
 
-    QList<WaylandSurface *> surfacesForClient(WaylandClient* client) const;
+    QList<QWaylandSurface *> surfacesForClient(WaylandClient* client) const;
 
-    void setDirectRenderSurface(WaylandSurface *surface, QOpenGLContext *context);
-    WaylandSurface *directRenderSurface() const;
+    void setDirectRenderSurface(QWaylandSurface *surface, QOpenGLContext *context);
+    QWaylandSurface *directRenderSurface() const;
 
     QWindow *window()const;
 
-    virtual void surfaceCreated(WaylandSurface *surface) = 0;
-    virtual void surfaceAboutToBeDestroyed(WaylandSurface *surface);
+    virtual void surfaceCreated(QWaylandSurface *surface) = 0;
+    virtual void surfaceAboutToBeDestroyed(QWaylandSurface *surface);
 
     virtual void openUrl(WaylandClient *client, const QUrl &url);
 
-    Wayland::Compositor *handle() const;
+    QtWayland::Compositor *handle() const;
 
     void setRetainedSelectionEnabled(bool enable);
     virtual void retainedSelectionReceived(QMimeData *mimeData);
@@ -101,13 +103,13 @@ public:
     void setOutputRefreshRate(int refreshRate);
     int outputRefreshRate() const;
 
-    WaylandInputDevice *defaultInputDevice() const;
+    QWaylandInputDevice *defaultInputDevice() const;
 
     bool isDragging() const;
-    void sendDragMoveEvent(const QPoint &global, const QPoint &local, WaylandSurface *surface);
+    void sendDragMoveEvent(const QPoint &global, const QPoint &local, QWaylandSurface *surface);
     void sendDragEndEvent();
 
-    virtual void setCursorSurface(WaylandSurface *surface, int hotspotX, int hotspotY);
+    virtual void setCursorSurface(QWaylandSurface *surface, int hotspotX, int hotspotY);
 
     void enableSubSurfaceExtension();
 
@@ -121,11 +123,13 @@ public:
 private:
     static void retainedSelectionChanged(QMimeData *mimeData, void *param);
 
-    Wayland::Compositor *m_compositor;
+    QtWayland::Compositor *m_compositor;
     QWindow  *m_toplevel_window;
     QByteArray m_socket_name;
 };
 
-Q_DECLARE_OPERATORS_FOR_FLAGS(WaylandCompositor::TouchExtensionFlags)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QWaylandCompositor::TouchExtensionFlags)
+
+QT_END_NAMESPACE
 
-#endif // QTCOMP_H
+#endif // QWAYLANDCOMPOSITOR_H
diff --git a/src/compositor/compositor_api/waylandinput.cpp b/src/compositor/compositor_api/qwaylandinput.cpp
index 4eaeae65e..c73784ebf 100644
--- a/src/compositor/compositor_api/waylandinput.cpp
+++ b/src/compositor/compositor_api/qwaylandinput.cpp
@@ -38,34 +38,36 @@
 **
 ****************************************************************************/
 
-#include "waylandinput.h"
+#include "qwaylandinput.h"
 
-#include "wlinputdevice.h"
-#include "waylandcompositor.h"
-#include "wlsurface.h"
-#include "wlcompositor.h"
+#include "qwlinputdevice_p.h"
+#include "qwaylandcompositor.h"
+#include "qwlsurface_p.h"
+#include "qwlcompositor_p.h"
 
-WaylandInputDevice::WaylandInputDevice(WaylandCompositor *compositor)
-    : d(new Wayland::InputDevice(this,compositor->handle()))
+QT_BEGIN_NAMESPACE
+
+QWaylandInputDevice::QWaylandInputDevice(QWaylandCompositor *compositor)
+    : d(new QtWayland::InputDevice(this,compositor->handle()))
 {
 }
 
-WaylandInputDevice::~WaylandInputDevice()
+QWaylandInputDevice::~QWaylandInputDevice()
 {
     delete d;
 }
 
-void WaylandInputDevice::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos)
+void QWaylandInputDevice::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos)
 {
     d->sendMousePressEvent(button,localPos,globalPos);
 }
 
-void WaylandInputDevice::sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos)
+void QWaylandInputDevice::sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos)
 {
     d->sendMouseReleaseEvent(button,localPos,globalPos);
 }
 
-void WaylandInputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos)
+void QWaylandInputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos)
 {
     d->sendMouseMoveEvent(localPos,globalPos);
 }
@@ -73,88 +75,88 @@ void WaylandInputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPoin
 /** Convenience function that will set the mouse focus to the surface, then send the mouse move event.
  *  If the mouse focus is the same surface as the surface passed in, then only the move event is sent
  **/
-void WaylandInputDevice::sendMouseMoveEvent(WaylandSurface *surface, const QPointF &localPos, const QPointF &globalPos)
+void QWaylandInputDevice::sendMouseMoveEvent(QWaylandSurface *surface, const QPointF &localPos, const QPointF &globalPos)
 {
-    Wayland::Surface *wlsurface = surface? surface->handle():0;
+    QtWayland::Surface *wlsurface = surface? surface->handle():0;
     d->sendMouseMoveEvent(wlsurface,localPos,globalPos);
 }
 
-void WaylandInputDevice::sendMouseWheelEvent(Qt::Orientation orientation, int delta)
+void QWaylandInputDevice::sendMouseWheelEvent(Qt::Orientation orientation, int delta)
 {
     d->sendMouseWheelEvent(orientation, delta);
 }
 
-void WaylandInputDevice::sendKeyPressEvent(uint code)
+void QWaylandInputDevice::sendKeyPressEvent(uint code)
 {
     d->sendKeyPressEvent(code);
 }
 
-void WaylandInputDevice::sendKeyReleaseEvent(uint code)
+void QWaylandInputDevice::sendKeyReleaseEvent(uint code)
 {
     d->sendKeyReleaseEvent(code);
 }
 
-void WaylandInputDevice::sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state)
+void QWaylandInputDevice::sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state)
 {
     d->sendTouchPointEvent(id,x,y,state);
 }
 
-void WaylandInputDevice::sendTouchFrameEvent()
+void QWaylandInputDevice::sendTouchFrameEvent()
 {
     d->sendTouchFrameEvent();
 }
 
-void WaylandInputDevice::sendTouchCancelEvent()
+void QWaylandInputDevice::sendTouchCancelEvent()
 {
     d->sendTouchCancelEvent();
 }
 
-void WaylandInputDevice::sendFullTouchEvent(QTouchEvent *event)
+void QWaylandInputDevice::sendFullTouchEvent(QTouchEvent *event)
 {
     d->sendFullTouchEvent(event);
 }
 
-void WaylandInputDevice::sendFullKeyEvent(QKeyEvent *event)
+void QWaylandInputDevice::sendFullKeyEvent(QKeyEvent *event)
 {
     d->sendFullKeyEvent(event);
 }
 
-WaylandSurface *WaylandInputDevice::keyboardFocus() const
+QWaylandSurface *QWaylandInputDevice::keyboardFocus() const
 {
-    Wayland::Surface *wlsurface = d->keyboardFocus();
+    QtWayland::Surface *wlsurface = d->keyboardFocus();
     if (wlsurface)
         return  wlsurface->waylandSurface();
     return 0;
 }
 
-bool WaylandInputDevice::setKeyboardFocus(WaylandSurface *surface)
+bool QWaylandInputDevice::setKeyboardFocus(QWaylandSurface *surface)
 {
-    Wayland::Surface *wlsurface = surface?surface->handle():0;
+    QtWayland::Surface *wlsurface = surface?surface->handle():0;
     return d->setKeyboardFocus(wlsurface);
 }
 
-WaylandSurface *WaylandInputDevice::mouseFocus() const
+QWaylandSurface *QWaylandInputDevice::mouseFocus() const
 {
-    Wayland::Surface *wlsurface = d->mouseFocus();
+    QtWayland::Surface *wlsurface = d->mouseFocus();
     if (wlsurface)
         return  wlsurface->waylandSurface();
     return 0;
 }
 
-void WaylandInputDevice::setMouseFocus(WaylandSurface *surface, const QPointF &localPos, const QPointF &globalPos)
+void QWaylandInputDevice::setMouseFocus(QWaylandSurface *surface, const QPointF &localPos, const QPointF &globalPos)
 {
-    Wayland::Surface *wlsurface = surface?surface->handle():0;
+    QtWayland::Surface *wlsurface = surface?surface->handle():0;
     d->setMouseFocus(wlsurface,localPos,globalPos);
 }
 
-WaylandCompositor *WaylandInputDevice::compositor() const
+QWaylandCompositor *QWaylandInputDevice::compositor() const
 {
     return d->compositor()->waylandCompositor();
 }
 
-Wayland::InputDevice *WaylandInputDevice::handle() const
+QtWayland::InputDevice *QWaylandInputDevice::handle() const
 {
     return d;
 }
 
-
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandinput.h b/src/compositor/compositor_api/qwaylandinput.h
index 622291072..b9d66178d 100644
--- a/src/compositor/compositor_api/waylandinput.h
+++ b/src/compositor/compositor_api/qwaylandinput.h
@@ -38,33 +38,35 @@
 **
 ****************************************************************************/
 
-#ifndef WAYLANDINPUT_H
-#define WAYLANDINPUT_H
+#ifndef QWAYLANDINPUT_H
+#define QWAYLANDINPUT_H
 
 #include <QtCore/qnamespace.h>
 #include <QtCore/QPoint>
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
-class WaylandCompositor;
-class WaylandSurface;
+class QWaylandCompositor;
+class QWaylandSurface;
 class QKeyEvent;
 class QTouchEvent;
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 class InputDevice;
 }
 
-class Q_COMPOSITOR_EXPORT WaylandInputDevice
+class Q_COMPOSITOR_EXPORT QWaylandInputDevice
 {
 public:
-    WaylandInputDevice(WaylandCompositor *compositor);
-    ~WaylandInputDevice();
+    QWaylandInputDevice(QWaylandCompositor *compositor);
+    ~QWaylandInputDevice();
 
     void sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF());
     void sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF());
     void sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos = QPointF());
-    void sendMouseMoveEvent(WaylandSurface *surface , const QPointF &localPos, const QPointF &globalPos = QPointF());
+    void sendMouseMoveEvent(QWaylandSurface *surface , const QPointF &localPos, const QPointF &globalPos = QPointF());
     void sendMouseWheelEvent(Qt::Orientation orientation, int delta);
 
     void sendKeyPressEvent(uint code);
@@ -78,18 +80,20 @@ public:
 
     void sendFullTouchEvent(QTouchEvent *event);
 
-    WaylandSurface *keyboardFocus() const;
-    bool setKeyboardFocus(WaylandSurface *surface);
+    QWaylandSurface *keyboardFocus() const;
+    bool setKeyboardFocus(QWaylandSurface *surface);
 
-    WaylandSurface *mouseFocus() const;
-    void setMouseFocus(WaylandSurface *surface, const QPointF &local_pos, const QPointF &global_pos = QPointF());
+    QWaylandSurface *mouseFocus() const;
+    void setMouseFocus(QWaylandSurface *surface, const QPointF &local_pos, const QPointF &global_pos = QPointF());
 
-    WaylandCompositor *compositor() const;
-    Wayland::InputDevice *handle() const;
+    QWaylandCompositor *compositor() const;
+    QtWayland::InputDevice *handle() const;
 
 private:
-    Wayland::InputDevice *d;
-    Q_DISABLE_COPY(WaylandInputDevice)
+    QtWayland::InputDevice *d;
+    Q_DISABLE_COPY(QWaylandInputDevice)
 };
 
-#endif // WAYLANDINPUT_H
+QT_END_NAMESPACE
+
+#endif // QWAYLANDINPUT_H
diff --git a/src/compositor/compositor_api/waylandsurface.cpp b/src/compositor/compositor_api/qwaylandsurface.cpp
index e30c148ad..f97169255 100644
--- a/src/compositor/compositor_api/waylandsurface.cpp
+++ b/src/compositor/compositor_api/qwaylandsurface.cpp
@@ -38,37 +38,39 @@
 **
 ****************************************************************************/
 
-#include "waylandsurface.h"
+#include "qwaylandsurface.h"
 
 #include <private/qobject_p.h>
 
-#include "wayland_wrapper/wlsurface.h"
-#include "wayland_wrapper/wlextendedsurface.h"
-#include "wayland_wrapper/wlsubsurface.h"
-#include "wayland_wrapper/wlcompositor.h"
-#include "wayland_wrapper/wlshellsurface.h"
+#include "wayland_wrapper/qwlsurface_p.h"
+#include "wayland_wrapper/qwlextendedsurface_p.h"
+#include "wayland_wrapper/qwlsubsurface_p.h"
+#include "wayland_wrapper/qwlcompositor_p.h"
+#include "wayland_wrapper/qwlshellsurface_p.h"
 
-#include "waylandcompositor.h"
+#include "qwaylandcompositor.h"
 #include "waylandwindowmanagerintegration.h"
 
 #include <QtGui/QGuiApplication>
 #include <QtGui/QScreen>
 
 #ifdef QT_COMPOSITOR_QUICK
-#include "waylandsurfaceitem.h"
+#include "qwaylandsurfaceitem.h"
 #endif
 
-class WaylandSurfacePrivate : public QObjectPrivate
+QT_BEGIN_NAMESPACE
+
+class QWaylandSurfacePrivate : public QObjectPrivate
 {
 public:
-    WaylandSurfacePrivate(Wayland::Surface *srfc)
+    QWaylandSurfacePrivate(QtWayland::Surface *srfc)
         : surface(srfc)
 #ifdef QT_COMPOSITOR_QUICK
         , surface_item(0)
 #endif
     {}
 
-    ~WaylandSurfacePrivate()
+    ~QWaylandSurfacePrivate()
     {
 #ifdef QT_COMPOSITOR_QUICK
         if (surface_item)
@@ -76,155 +78,155 @@ public:
 #endif
     }
 
-    Wayland::Surface *surface;
+    QtWayland::Surface *surface;
 #ifdef QT_COMPOSITOR_QUICK
-    WaylandSurfaceItem *surface_item;
+    QWaylandSurfaceItem *surface_item;
 #endif
 };
 
-WaylandSurface::WaylandSurface(Wayland::Surface *surface)
-    : QObject(*new WaylandSurfacePrivate(surface))
+QWaylandSurface::QWaylandSurface(QtWayland::Surface *surface)
+    : QObject(*new QWaylandSurfacePrivate(surface))
 {
 }
 
-WaylandClient *WaylandSurface::client() const
+WaylandClient *QWaylandSurface::client() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->base()->resource.client;
 }
 
-WaylandSurface *WaylandSurface::parentSurface() const
+QWaylandSurface *QWaylandSurface::parentSurface() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (d->surface->subSurface() && d->surface->subSurface()->parent()) {
         return d->surface->subSurface()->parent()->waylandSurface();
     }
     return 0;
 }
 
-QLinkedList<WaylandSurface *> WaylandSurface::subSurfaces() const
+QLinkedList<QWaylandSurface *> QWaylandSurface::subSurfaces() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (d->surface->subSurface()) {
         return d->surface->subSurface()->subSurfaces();
     }
-    return QLinkedList<WaylandSurface *>();
+    return QLinkedList<QWaylandSurface *>();
 }
 
-WaylandSurface::Type WaylandSurface::type() const
+QWaylandSurface::Type QWaylandSurface::type() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->type();
 }
 
-bool WaylandSurface::isYInverted() const
+bool QWaylandSurface::isYInverted() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->isYInverted();
 }
 
-bool WaylandSurface::visible() const
+bool QWaylandSurface::visible() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->visible();
 }
 
-QPointF WaylandSurface::pos() const
+QPointF QWaylandSurface::pos() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->pos();
 }
 
-void WaylandSurface::setPos(const QPointF &pos)
+void QWaylandSurface::setPos(const QPointF &pos)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     d->surface->setPos(pos);
 }
 
-QSize WaylandSurface::size() const
+QSize QWaylandSurface::size() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->size();
 }
 
-void WaylandSurface::setSize(const QSize &size)
+void QWaylandSurface::setSize(const QSize &size)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     d->surface->setSize(size);
 }
 
-void WaylandSurface::sendConfigure(const QSize &size)
+void QWaylandSurface::sendConfigure(const QSize &size)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     if (d->surface->shellSurface())
         d->surface->shellSurface()->sendConfigure(WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT, size.width(), size.height());
 }
 
-Qt::ScreenOrientations WaylandSurface::orientationUpdateMask() const
+Qt::ScreenOrientations QWaylandSurface::orientationUpdateMask() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->compositor()->orientationUpdateMaskForClient(static_cast<wl_client *>(client()));
 }
 
-Qt::ScreenOrientation WaylandSurface::contentOrientation() const
+Qt::ScreenOrientation QWaylandSurface::contentOrientation() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (!d->surface->extendedSurface())
         return Qt::PrimaryOrientation;
     return d->surface->extendedSurface()->contentOrientation();
 }
 
-WaylandSurface::WindowFlags WaylandSurface::windowFlags() const
+QWaylandSurface::WindowFlags QWaylandSurface::windowFlags() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (!d->surface->extendedSurface())
-        return WaylandSurface::WindowFlags(0);
+        return QWaylandSurface::WindowFlags(0);
     return d->surface->extendedSurface()->windowFlags();
 }
 
 
-QImage WaylandSurface::image() const
+QImage QWaylandSurface::image() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->image();
 }
 
 #ifdef QT_COMPOSITOR_WAYLAND_GL
-GLuint WaylandSurface::texture(QOpenGLContext *context) const
+GLuint QWaylandSurface::texture(QOpenGLContext *context) const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->textureId(context);
 }
 #else //QT_COMPOSITOR_WAYLAND_GL
-uint WaylandSurface::texture(QOpenGLContext *) const
+uint QWaylandSurface::texture(QOpenGLContext *) const
 {
     return 0;
 }
 #endif
 
-Wayland::Surface * WaylandSurface::handle() const
+QtWayland::Surface * QWaylandSurface::handle() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface;
 }
 
 #ifdef QT_COMPOSITOR_QUICK
-WaylandSurfaceItem *WaylandSurface::surfaceItem() const
+QWaylandSurfaceItem *QWaylandSurface::surfaceItem() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface_item;
 }
 
-void WaylandSurface::setSurfaceItem(WaylandSurfaceItem *surfaceItem)
+void QWaylandSurface::setSurfaceItem(QWaylandSurfaceItem *surfaceItem)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     d->surface_item = surfaceItem;
 }
 #endif //QT_COMPOSITOR_QUICK
 
-qint64 WaylandSurface::processId() const
+qint64 QWaylandSurface::processId() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     WindowManagerServerIntegration *wmIntegration = d->surface->compositor()->windowManagerIntegration();
     if (!wmIntegration) {
         return 0;
@@ -234,9 +236,9 @@ qint64 WaylandSurface::processId() const
     return mcl ? mcl->processId() : 0;
 }
 
-QByteArray WaylandSurface::authenticationToken() const
+QByteArray QWaylandSurface::authenticationToken() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     WindowManagerServerIntegration *wmIntegration = d->surface->compositor()->windowManagerIntegration();
     if (!wmIntegration) {
         return QByteArray();
@@ -246,34 +248,34 @@ QByteArray WaylandSurface::authenticationToken() const
     return mcl ? mcl->authenticationToken() : QByteArray();
 }
 
-QVariantMap WaylandSurface::windowProperties() const
+QVariantMap QWaylandSurface::windowProperties() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (!d->surface->extendedSurface())
         return QVariantMap();
 
     return d->surface->extendedSurface()->windowProperties();
 }
 
-void WaylandSurface::setWindowProperty(const QString &name, const QVariant &value)
+void QWaylandSurface::setWindowProperty(const QString &name, const QVariant &value)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     if (!d->surface->extendedSurface())
         return;
 
     d->surface->extendedSurface()->setWindowProperty(name, value);
 }
 
-QPointF WaylandSurface::mapToParent(const QPointF &pos) const
+QPointF QWaylandSurface::mapToParent(const QPointF &pos) const
 {
     return pos + this->pos();
 }
 
-QPointF WaylandSurface::mapTo(WaylandSurface *parent, const QPointF &pos) const
+QPointF QWaylandSurface::mapTo(QWaylandSurface *parent, const QPointF &pos) const
 {
     QPointF p = pos;
     if (parent) {
-        const WaylandSurface * surface = this;
+        const QWaylandSurface * surface = this;
         while (surface != parent) {
             Q_ASSERT_X(surface, "WaylandSurface::mapTo(WaylandSurface *parent, const QPoint &pos)",
                        "parent must be in parent hierarchy");
@@ -284,48 +286,48 @@ QPointF WaylandSurface::mapTo(WaylandSurface *parent, const QPointF &pos) const
     return p;
 }
 
-WaylandCompositor *WaylandSurface::compositor() const
+QWaylandCompositor *QWaylandSurface::compositor() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->compositor()->waylandCompositor();
 }
 
-void WaylandSurface::frameFinished()
+void QWaylandSurface::frameFinished()
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     d->surface->frameFinished();
 }
 
-WaylandSurface *WaylandSurface::transientParent() const
+QWaylandSurface *QWaylandSurface::transientParent() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (d->surface->shellSurface() && d->surface->shellSurface()->transientParent())
         return d->surface->shellSurface()->transientParent()->surface()->waylandSurface();
     return 0;
 }
 
-void WaylandSurface::sendOnScreenVisibilityChange(bool visible)
+void QWaylandSurface::sendOnScreenVisibilityChange(bool visible)
 {
-    Q_D(WaylandSurface);
+    Q_D(QWaylandSurface);
     if (d->surface->extendedSurface())
         d->surface->extendedSurface()->sendOnScreenVisibility(visible);
 }
 
-QString WaylandSurface::className() const
+QString QWaylandSurface::className() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->className();
 }
 
-QString WaylandSurface::title() const
+QString QWaylandSurface::title() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->title();
 }
 
-bool WaylandSurface::hasShellSurface() const
+bool QWaylandSurface::hasShellSurface() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     if (d->surface->shellSurface())
         return true;
 
@@ -335,8 +337,10 @@ bool WaylandSurface::hasShellSurface() const
 /*!
  * \return True if WL_SHELL_SURFACE_TRANSIENT_INACTIVE was set for this surface, meaning it should not receive keyboard focus.
  */
-bool WaylandSurface::transientInactive() const
+bool QWaylandSurface::transientInactive() const
 {
-    Q_D(const WaylandSurface);
+    Q_D(const QWaylandSurface);
     return d->surface->transientInactive();
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandsurface.h b/src/compositor/compositor_api/qwaylandsurface.h
index e21f124aa..544fbc047 100644
--- a/src/compositor/compositor_api/waylandsurface.h
+++ b/src/compositor/compositor_api/qwaylandsurface.h
@@ -38,10 +38,10 @@
 **
 ****************************************************************************/
 
-#ifndef WAYLANDSURFACE_H
-#define WAYLANDSURFACE_H
+#ifndef QWAYLANDSURFACE_H
+#define QWAYLANDSURFACE_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
 #include <QtCore/QScopedPointer>
 #include <QtGui/QImage>
@@ -52,27 +52,29 @@
 #include <QtGui/qopengl.h>
 #endif
 
+QT_BEGIN_NAMESPACE
+
 class QTouchEvent;
-class WaylandSurfacePrivate;
-class WaylandCompositor;
+class QWaylandSurfacePrivate;
+class QWaylandCompositor;
 
 #ifdef QT_COMPOSITOR_QUICK
-class WaylandSurfaceItem;
+class QWaylandSurfaceItem;
 #endif
 
-namespace Wayland {
+namespace QtWayland {
 class Surface;
 class SurfacePrivate;
 class ExtendedSurface;
 }
 
-class Q_COMPOSITOR_EXPORT WaylandSurface : public QObject
+class Q_COMPOSITOR_EXPORT QWaylandSurface : public QObject
 {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(WaylandSurface)
+    Q_DECLARE_PRIVATE(QWaylandSurface)
     Q_PROPERTY(QSize size READ size WRITE setSize NOTIFY sizeChanged)
     Q_PROPERTY(QPointF pos READ pos WRITE setPos NOTIFY posChanged)
-    Q_PROPERTY(WaylandSurface::WindowFlags windowFlags READ windowFlags NOTIFY windowFlagsChanged)
+    Q_PROPERTY(QWaylandSurface::WindowFlags windowFlags READ windowFlags NOTIFY windowFlagsChanged)
     Q_PROPERTY(Qt::ScreenOrientation contentOrientation READ contentOrientation NOTIFY contentOrientationChanged)
     Q_PROPERTY(QString className READ className NOTIFY classNameChanged)
     Q_PROPERTY(QString title READ title NOTIFY titleChanged)
@@ -94,12 +96,12 @@ public:
         Texture
     };
 
-    WaylandSurface(Wayland::Surface *surface = 0);
+    QWaylandSurface(QtWayland::Surface *surface = 0);
 
     WaylandClient *client() const;
 
-    WaylandSurface *parentSurface() const;
-    QLinkedList<WaylandSurface *> subSurfaces() const;
+    QWaylandSurface *parentSurface() const;
+    QLinkedList<QWaylandSurface *> subSurfaces() const;
 
     Type type() const;
     bool isYInverted() const;
@@ -128,13 +130,13 @@ public:
 
     void frameFinished();
 
-    WaylandSurface *transientParent() const;
+    QWaylandSurface *transientParent() const;
 
-    Wayland::Surface *handle() const;
+    QtWayland::Surface *handle() const;
 
 #ifdef QT_COMPOSITOR_QUICK
-    WaylandSurfaceItem *surfaceItem() const;
-    void setSurfaceItem(WaylandSurfaceItem *surfaceItem);
+    QWaylandSurfaceItem *surfaceItem() const;
+    void setSurfaceItem(QWaylandSurfaceItem *surfaceItem);
 #endif
 
     qint64 processId() const;
@@ -143,9 +145,9 @@ public:
     void setWindowProperty(const QString &name, const QVariant &value);
 
     QPointF mapToParent(const QPointF &) const;
-    QPointF mapTo(WaylandSurface *, const QPointF &) const;
+    QPointF mapTo(QWaylandSurface *, const QPointF &) const;
 
-    WaylandCompositor *compositor() const;
+    QWaylandCompositor *compositor() const;
 
     QString className() const;
 
@@ -159,7 +161,7 @@ signals:
     void mapped();
     void unmapped();
     void damaged(const QRect &rect);
-    void parentChanged(WaylandSurface *newParent, WaylandSurface *oldParent);
+    void parentChanged(QWaylandSurface *newParent, QWaylandSurface *oldParent);
     void sizeChanged();
     void posChanged();
     void windowPropertyChanged(const QString &name, const QVariant &value);
@@ -172,4 +174,6 @@ signals:
 
 };
 
-#endif // WAYLANDSURFACE_H
+QT_END_NAMESPACE
+
+#endif // QWAYLANDSURFACE_H
diff --git a/src/compositor/compositor_api/waylandsurfaceitem.cpp b/src/compositor/compositor_api/qwaylandsurfaceitem.cpp
index f90809bc9..787db1770 100644
--- a/src/compositor/compositor_api/waylandsurfaceitem.cpp
+++ b/src/compositor/compositor_api/qwaylandsurfaceitem.cpp
@@ -38,14 +38,14 @@
 **
 ****************************************************************************/
 
-#include "waylandsurfaceitem.h"
-#include "waylandsurfacenode.h"
-#include "waylandsurface.h"
-#include "waylandcompositor.h"
-#include "waylandinput.h"
+#include "qwaylandsurfaceitem.h"
+#include "qwaylandsurfacenode_p.h"
+#include "qwaylandsurface.h"
+#include "qwaylandcompositor.h"
+#include "qwaylandinput.h"
 
-#include "wlsurface.h"
-#include "wlextendedsurface.h"
+#include "qwlsurface_p.h"
+#include "qwlextendedsurface_p.h"
 
 #include <QtGui/QKeyEvent>
 #include <QtGui/QGuiApplication>
@@ -57,14 +57,15 @@
 #include <QtCore/QMutexLocker>
 #include <QtCore/QMutex>
 
+QT_BEGIN_NAMESPACE
 
-class WaylandSurfaceTextureProvider : public QSGTextureProvider
+class QWaylandSurfaceTextureProvider : public QSGTextureProvider
 {
     Q_OBJECT
 
 public:
-    WaylandSurfaceTextureProvider() : t(0) { }
-    ~WaylandSurfaceTextureProvider() { delete t; }
+    QWaylandSurfaceTextureProvider() : t(0) { }
+    ~QWaylandSurfaceTextureProvider() { delete t; }
 
     QSGTexture *texture() const {
         if (t)
@@ -83,9 +84,9 @@ public slots:
     }
 };
 
-QMutex *WaylandSurfaceItem::mutex = 0;
+QMutex *QWaylandSurfaceItem::mutex = 0;
 
-WaylandSurfaceItem::WaylandSurfaceItem(QQuickItem *parent)
+QWaylandSurfaceItem::QWaylandSurfaceItem(QQuickItem *parent)
     : QQuickItem(parent)
     , m_surface(0)
     , m_provider(0)
@@ -99,7 +100,7 @@ WaylandSurfaceItem::WaylandSurfaceItem(QQuickItem *parent)
         mutex = new QMutex;
 }
 
-WaylandSurfaceItem::WaylandSurfaceItem(WaylandSurface *surface, QQuickItem *parent)
+QWaylandSurfaceItem::QWaylandSurfaceItem(QWaylandSurface *surface, QQuickItem *parent)
     : QQuickItem(parent)
     , m_surface(0)
     , m_provider(0)
@@ -112,7 +113,7 @@ WaylandSurfaceItem::WaylandSurfaceItem(WaylandSurface *surface, QQuickItem *pare
     init(surface);
 }
 
-void WaylandSurfaceItem::init(WaylandSurface *surface)
+void QWaylandSurfaceItem::init(QWaylandSurface *surface)
 {
     if (!surface)
         return;
@@ -142,8 +143,8 @@ void WaylandSurfaceItem::init(WaylandSurface *surface)
     connect(surface, SIGNAL(unmapped()), this, SLOT(surfaceUnmapped()));
     connect(surface, SIGNAL(destroyed(QObject *)), this, SLOT(surfaceDestroyed(QObject *)));
     connect(surface, SIGNAL(damaged(const QRect &)), this, SLOT(surfaceDamaged(const QRect &)));
-    connect(surface, SIGNAL(parentChanged(WaylandSurface*,WaylandSurface*)),
-            this, SLOT(parentChanged(WaylandSurface*,WaylandSurface*)));
+    connect(surface, SIGNAL(parentChanged(QWaylandSurface*,QWaylandSurface*)),
+            this, SLOT(parentChanged(QWaylandSurface*,QWaylandSurface*)));
     connect(surface, SIGNAL(sizeChanged()), this, SLOT(updateSize()));
     connect(surface, SIGNAL(posChanged()), this, SLOT(updatePosition()));
 
@@ -151,7 +152,7 @@ void WaylandSurfaceItem::init(WaylandSurface *surface)
     m_yInverted = surface ? surface->isYInverted() : true;
 }
 
-WaylandSurfaceItem::~WaylandSurfaceItem()
+QWaylandSurfaceItem::~QWaylandSurfaceItem()
 {
     QMutexLocker locker(mutex);
     if (m_node)
@@ -162,7 +163,7 @@ WaylandSurfaceItem::~WaylandSurfaceItem()
         m_provider->deleteLater();
 }
 
-void WaylandSurfaceItem::setSurface(WaylandSurface *surface)
+void QWaylandSurfaceItem::setSurface(QWaylandSurface *surface)
 {
     if (surface == m_surface)
         return;
@@ -171,79 +172,79 @@ void WaylandSurfaceItem::setSurface(WaylandSurface *surface)
     emit surfaceChanged();
 }
 
-bool WaylandSurfaceItem::isYInverted() const
+bool QWaylandSurfaceItem::isYInverted() const
 {
     return m_yInverted;
 }
 
-QSGTextureProvider *WaylandSurfaceItem::textureProvider() const
+QSGTextureProvider *QWaylandSurfaceItem::textureProvider() const
 {
-    const_cast<WaylandSurfaceItem *>(this)->ensureProvider();
+    const_cast<QWaylandSurfaceItem *>(this)->ensureProvider();
     return m_provider;
 }
 
-void WaylandSurfaceItem::ensureProvider()
+void QWaylandSurfaceItem::ensureProvider()
 {
     if (!m_provider) {
-        m_provider = new WaylandSurfaceTextureProvider();
+        m_provider = new QWaylandSurfaceTextureProvider();
         connect(window(), SIGNAL(sceneGraphInvalidated()), m_provider, SLOT(invalidate()), Qt::DirectConnection);
     }
 }
 
-void WaylandSurfaceItem::mousePressEvent(QMouseEvent *event)
+void QWaylandSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
     if (m_surface) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         if (inputDevice->mouseFocus() != m_surface)
             inputDevice->setMouseFocus(m_surface, event->pos(), event->globalPos());
         inputDevice->sendMousePressEvent(event->button(), toSurface(event->pos()), event->globalPos());
     }
 }
 
-void WaylandSurfaceItem::mouseMoveEvent(QMouseEvent *event)
+void QWaylandSurfaceItem::mouseMoveEvent(QMouseEvent *event)
 {
     if (m_surface){
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->sendMouseMoveEvent(m_surface, toSurface(event->pos()), event->globalPos());
     }
 }
 
-void WaylandSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
+void QWaylandSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
 {
     if (m_surface){
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->sendMouseReleaseEvent(event->button(), toSurface(event->pos()), event->globalPos());
     }
 }
 
-void WaylandSurfaceItem::wheelEvent(QWheelEvent *event)
+void QWaylandSurfaceItem::wheelEvent(QWheelEvent *event)
 {
     if (m_surface) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->sendMouseWheelEvent(event->orientation(), event->delta());
     }
 }
 
-void WaylandSurfaceItem::keyPressEvent(QKeyEvent *event)
+void QWaylandSurfaceItem::keyPressEvent(QKeyEvent *event)
 {
     if (m_surface && hasFocus()) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->sendFullKeyEvent(event);
     }
 }
 
-void WaylandSurfaceItem::keyReleaseEvent(QKeyEvent *event)
+void QWaylandSurfaceItem::keyReleaseEvent(QKeyEvent *event)
 {
     if (m_surface && hasFocus()) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->sendFullKeyEvent(event);
     }
 }
 
-void WaylandSurfaceItem::touchEvent(QTouchEvent *event)
+void QWaylandSurfaceItem::touchEvent(QTouchEvent *event)
 {
     if (m_touchEventsEnabled && m_surface) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         event->accept();
         if (inputDevice->mouseFocus() != m_surface) {
             QPoint pointPos;
@@ -258,43 +259,43 @@ void WaylandSurfaceItem::touchEvent(QTouchEvent *event)
     }
 }
 
-void WaylandSurfaceItem::takeFocus()
+void QWaylandSurfaceItem::takeFocus()
 {
     setFocus(true);
 
     if (m_surface) {
-        WaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
+        QWaylandInputDevice *inputDevice = m_surface->compositor()->defaultInputDevice();
         inputDevice->setKeyboardFocus(m_surface);
     }
 }
 
-QPoint WaylandSurfaceItem::toSurface(const QPointF &pos) const
+QPoint QWaylandSurfaceItem::toSurface(const QPointF &pos) const
 {
     return pos.toPoint();
 }
 
-void WaylandSurfaceItem::surfaceMapped()
+void QWaylandSurfaceItem::surfaceMapped()
 {
     setPaintEnabled(true);
 }
 
-void WaylandSurfaceItem::surfaceUnmapped()
+void QWaylandSurfaceItem::surfaceUnmapped()
 {
     setPaintEnabled(false);
 }
 
-void WaylandSurfaceItem::surfaceDestroyed(QObject *)
+void QWaylandSurfaceItem::surfaceDestroyed(QObject *)
 {
     m_surface = 0;
 }
 
-void WaylandSurfaceItem::setDamagedFlag(bool on)
+void QWaylandSurfaceItem::setDamagedFlag(bool on)
 {
     m_damaged = on;
 }
 
 
-void WaylandSurfaceItem::surfaceDamaged(const QRect &)
+void QWaylandSurfaceItem::surfaceDamaged(const QRect &)
 {
     m_damaged = true;
     if (m_surface) {
@@ -308,11 +309,11 @@ void WaylandSurfaceItem::surfaceDamaged(const QRect &)
     update();
 }
 
-void WaylandSurfaceItem::parentChanged(WaylandSurface *newParent, WaylandSurface *oldParent)
+void QWaylandSurfaceItem::parentChanged(QWaylandSurface *newParent, QWaylandSurface *oldParent)
 {
     Q_UNUSED(oldParent);
 
-    WaylandSurfaceItem *item = newParent? newParent->surfaceItem():0;
+    QWaylandSurfaceItem *item = newParent? newParent->surfaceItem():0;
     setParentItem(item);
 
     if (newParent) {
@@ -323,35 +324,35 @@ void WaylandSurfaceItem::parentChanged(WaylandSurface *newParent, WaylandSurface
     }
 }
 
-void WaylandSurfaceItem::updateSize()
+void QWaylandSurfaceItem::updateSize()
 {
     setSize(m_surface->size());
 }
 
-void WaylandSurfaceItem::updatePosition()
+void QWaylandSurfaceItem::updatePosition()
 {
     setPosition(m_surface->pos());
 }
 
-bool WaylandSurfaceItem::paintEnabled() const
+bool QWaylandSurfaceItem::paintEnabled() const
 {
     return m_paintEnabled;
 }
 
-void WaylandSurfaceItem::setPaintEnabled(bool enabled)
+void QWaylandSurfaceItem::setPaintEnabled(bool enabled)
 {
     m_paintEnabled = enabled;
     update();
 }
 
-void WaylandSurfaceItem::updateTexture()
+void QWaylandSurfaceItem::updateTexture()
 {
     ensureProvider();
     QSGTexture *texture = m_provider->t;
     if (m_damaged) {
         m_damaged = false;
         QSGTexture *oldTexture = texture;
-        if (m_surface->type() == WaylandSurface::Texture) {
+        if (m_surface->type() == QWaylandSurface::Texture) {
             QOpenGLContext *context = QOpenGLContext::currentContext();
             QQuickWindow::CreateTextureOptions opt = 0;
             if (useTextureAlpha()) {
@@ -369,7 +370,7 @@ void WaylandSurfaceItem::updateTexture()
     m_provider->smooth = smooth();
 }
 
-QSGNode *WaylandSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QWaylandSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
 {
     if (!m_surface) {
         delete oldNode;
@@ -382,10 +383,10 @@ QSGNode *WaylandSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeDa
         return 0;
     }
 
-    WaylandSurfaceNode *node = static_cast<WaylandSurfaceNode *>(oldNode);
+    QWaylandSurfaceNode *node = static_cast<QWaylandSurfaceNode *>(oldNode);
 
     if (!node) {
-        node = new WaylandSurfaceNode(this);
+        node = new QWaylandSurfaceNode(this);
     }
 
     node->updateTexture();
@@ -401,7 +402,7 @@ QSGNode *WaylandSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeDa
     return node;
 }
 
-void WaylandSurfaceItem::setUseTextureAlpha(bool useTextureAlpha)
+void QWaylandSurfaceItem::setUseTextureAlpha(bool useTextureAlpha)
 {
     m_useTextureAlpha = useTextureAlpha;
 
@@ -410,7 +411,7 @@ void WaylandSurfaceItem::setUseTextureAlpha(bool useTextureAlpha)
     }
 }
 
-void WaylandSurfaceItem::setClientRenderingEnabled(bool enabled)
+void QWaylandSurfaceItem::setClientRenderingEnabled(bool enabled)
 {
     if (m_clientRenderingEnabled != enabled) {
         m_clientRenderingEnabled = enabled;
@@ -423,7 +424,7 @@ void WaylandSurfaceItem::setClientRenderingEnabled(bool enabled)
     }
 }
 
-void WaylandSurfaceItem::setTouchEventsEnabled(bool enabled)
+void QWaylandSurfaceItem::setTouchEventsEnabled(bool enabled)
 {
     if (m_touchEventsEnabled != enabled) {
         m_touchEventsEnabled = enabled;
@@ -431,4 +432,6 @@ void WaylandSurfaceItem::setTouchEventsEnabled(bool enabled)
     }
 }
 
-#include "waylandsurfaceitem.moc"
+#include "qwaylandsurfaceitem.moc"
+
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandsurfaceitem.h b/src/compositor/compositor_api/qwaylandsurfaceitem.h
index 6888262ab..cc3323dd0 100644
--- a/src/compositor/compositor_api/waylandsurfaceitem.h
+++ b/src/compositor/compositor_api/qwaylandsurfaceitem.h
@@ -38,27 +38,29 @@
 **
 ****************************************************************************/
 
-#ifndef WAYLANDSURFACEITEM_H
-#define WAYLANDSURFACEITEM_H
+#ifndef QWAYLANDSURFACEITEM_H
+#define QWAYLANDSURFACEITEM_H
 
-#include "waylandexport.h"
-#include "waylandsurface.h"
+#include <QtCompositor/qwaylandexport.h>
+#include <QtCompositor/qwaylandsurface.h>
 
 #include <QtQuick/QQuickItem>
 #include <QtQuick/qsgtexture.h>
 
 #include <QtQuick/qsgtextureprovider.h>
 
-class WaylandSurfaceTextureProvider;
-class WaylandSurfaceNode;
+QT_BEGIN_NAMESPACE
+
+class QWaylandSurfaceTextureProvider;
+class QWaylandSurfaceNode;
 class QMutex;
 
-Q_DECLARE_METATYPE(WaylandSurface*)
+Q_DECLARE_METATYPE(QWaylandSurface*)
 
-class Q_COMPOSITOR_EXPORT WaylandSurfaceItem : public QQuickItem
+class Q_COMPOSITOR_EXPORT QWaylandSurfaceItem : public QQuickItem
 {
     Q_OBJECT
-    Q_PROPERTY(WaylandSurface* surface READ surface WRITE setSurface NOTIFY surfaceChanged)
+    Q_PROPERTY(QWaylandSurface* surface READ surface WRITE setSurface NOTIFY surfaceChanged)
     Q_PROPERTY(bool paintEnabled READ paintEnabled WRITE setPaintEnabled)
     Q_PROPERTY(bool useTextureAlpha READ useTextureAlpha WRITE setUseTextureAlpha NOTIFY useTextureAlphaChanged)
     Q_PROPERTY(bool clientRenderingEnabled READ clientRenderingEnabled WRITE setClientRenderingEnabled NOTIFY clientRenderingEnabledChanged)
@@ -66,12 +68,12 @@ class Q_COMPOSITOR_EXPORT WaylandSurfaceItem : public QQuickItem
     Q_PROPERTY(bool isYInverted READ isYInverted NOTIFY yInvertedChanged)
 
 public:
-    WaylandSurfaceItem(QQuickItem *parent = 0);
-    WaylandSurfaceItem(WaylandSurface *surface, QQuickItem *parent = 0);
-    ~WaylandSurfaceItem();
+    QWaylandSurfaceItem(QQuickItem *parent = 0);
+    QWaylandSurfaceItem(QWaylandSurface *surface, QQuickItem *parent = 0);
+    ~QWaylandSurfaceItem();
 
-    void setSurface(WaylandSurface *surface);
-    WaylandSurface *surface() const {return m_surface; }
+    void setSurface(QWaylandSurface *surface);
+    QWaylandSurface *surface() const {return m_surface; }
 
     Q_INVOKABLE bool isYInverted() const;
 
@@ -109,7 +111,7 @@ private slots:
     void surfaceUnmapped();
     void surfaceDestroyed(QObject *object);
     void surfaceDamaged(const QRect &);
-    void parentChanged(WaylandSurface *newParent, WaylandSurface *oldParent);
+    void parentChanged(QWaylandSurface *newParent, QWaylandSurface *oldParent);
     void updateSize();
     void updatePosition();
 
@@ -125,17 +127,17 @@ protected:
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
 
 private:
-    friend class WaylandSurfaceNode;
+    friend class QWaylandSurfaceNode;
     void updateTexture();
     QPoint toSurface(const QPointF &pos) const;
-    void init(WaylandSurface *);
+    void init(QWaylandSurface *);
     void ensureProvider();
 
     static QMutex *mutex;
 
-    WaylandSurface *m_surface;
-    WaylandSurfaceTextureProvider *m_provider;
-    WaylandSurfaceNode *m_node;
+    QWaylandSurface *m_surface;
+    QWaylandSurfaceTextureProvider *m_provider;
+    QWaylandSurfaceNode *m_node;
     bool m_paintEnabled;
     bool m_useTextureAlpha;
     bool m_clientRenderingEnabled;
@@ -144,4 +146,6 @@ private:
     bool m_yInverted;
 };
 
+QT_END_NAMESPACE
+
 #endif
diff --git a/src/compositor/compositor_api/waylandsurfacenode.cpp b/src/compositor/compositor_api/qwaylandsurfacenode.cpp
index a6188ff7f..513704f17 100644
--- a/src/compositor/compositor_api/waylandsurfacenode.cpp
+++ b/src/compositor/compositor_api/qwaylandsurfacenode.cpp
@@ -39,22 +39,24 @@
 **
 ****************************************************************************/
 
-#include "waylandsurfacenode.h"
-#include "waylandsurfaceitem.h"
+#include "qwaylandsurfacenode_p.h"
+#include "qwaylandsurfaceitem.h"
 
 #include <QtCore/QMutexLocker>
 #include <QtQuick/QSGTexture>
 #include <QtQuick/QSGSimpleTextureNode>
 #include <QtQuick/QSGFlatColorMaterial>
 
-WaylandSurfaceNode::WaylandSurfaceNode(WaylandSurfaceItem *item)
+QT_BEGIN_NAMESPACE
+
+QWaylandSurfaceNode::QWaylandSurfaceNode(QWaylandSurfaceItem *item)
     : m_item(item)
     , m_textureUpdated(false)
     , m_useTextureAlpha(false)
     , m_geometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4)
 {
-    m_textureMaterial = WaylandSurfaceTextureMaterial::createMaterial();
-    m_opaqueTextureMaterial = WaylandSurfaceTextureOpaqueMaterial::createMaterial();
+    m_textureMaterial = QWaylandSurfaceTextureMaterial::createMaterial();
+    m_opaqueTextureMaterial = QWaylandSurfaceTextureOpaqueMaterial::createMaterial();
 
     m_currentMaterial = m_opaqueTextureMaterial;
 
@@ -67,18 +69,18 @@ WaylandSurfaceNode::WaylandSurfaceNode(WaylandSurfaceItem *item)
 }
 
 
-WaylandSurfaceNode::~WaylandSurfaceNode()
+QWaylandSurfaceNode::~QWaylandSurfaceNode()
 {
-    QMutexLocker locker(WaylandSurfaceItem::mutex);
+    QMutexLocker locker(QWaylandSurfaceItem::mutex);
     if (m_item)
         m_item->m_node = 0;
     delete m_textureMaterial;
     delete m_opaqueTextureMaterial;
 }
 
-void WaylandSurfaceNode::preprocess()
+void QWaylandSurfaceNode::preprocess()
 {
-    QMutexLocker locker(WaylandSurfaceItem::mutex);
+    QMutexLocker locker(QWaylandSurfaceItem::mutex);
 
     if (m_item && m_item->surface()) {
         //Update if the item is dirty and we haven't done an updateTexture for this frame
@@ -91,7 +93,7 @@ void WaylandSurfaceNode::preprocess()
     m_textureUpdated = false;
 }
 
-void WaylandSurfaceNode::updateTexture()
+void QWaylandSurfaceNode::updateTexture()
 {
     Q_ASSERT(m_item && m_item->textureProvider());
 
@@ -111,7 +113,7 @@ void WaylandSurfaceNode::updateTexture()
     setTexture(texture);
 }
 
-void WaylandSurfaceNode::setRect(const QRectF &rect)
+void QWaylandSurfaceNode::setRect(const QRectF &rect)
 {
     if (m_rect == rect)
         return;
@@ -124,7 +126,7 @@ void WaylandSurfaceNode::setRect(const QRectF &rect)
     }
 }
 
-void WaylandSurfaceNode::setTexture(QSGTexture *texture)
+void QWaylandSurfaceNode::setTexture(QSGTexture *texture)
 {
     if (m_currentMaterial->state()->texture() == texture)
         return;
@@ -136,12 +138,14 @@ void WaylandSurfaceNode::setTexture(QSGTexture *texture)
     markDirty(DirtyMaterial);
 }
 
-QSGTexture *WaylandSurfaceNode::texture() const
+QSGTexture *QWaylandSurfaceNode::texture() const
 {
     return m_currentMaterial->state()->texture();
 }
 
-void WaylandSurfaceNode::setItem(WaylandSurfaceItem *item)
+void QWaylandSurfaceNode::setItem(QWaylandSurfaceItem *item)
 {
     m_item = item;
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandsurfacenode.h b/src/compositor/compositor_api/qwaylandsurfacenode_p.h
index f4c9c0ece..99bca039d 100644
--- a/src/compositor/compositor_api/waylandsurfacenode.h
+++ b/src/compositor/compositor_api/qwaylandsurfacenode_p.h
@@ -39,22 +39,24 @@
 **
 ****************************************************************************/
 
-#ifndef WAYLANDSURFACENODE_H
-#define WAYLANDSURFACENODE_H
+#ifndef QWAYLANDSURFACENODE_H
+#define QWAYLANDSURFACENODE_H
 
-#include "waylandsurfacetexturematerial.h"
+#include "qwaylandsurfacetexturematerial_p.h"
 
 #include <QtQuick/QSGGeometryNode>
 #include <QtQuick/QSGOpaqueTextureMaterial>
 
-class WaylandSurfaceItem;
+QT_BEGIN_NAMESPACE
+
+class QWaylandSurfaceItem;
 class QSGTexture;
 
-class WaylandSurfaceNode : public QSGGeometryNode
+class QWaylandSurfaceNode : public QSGGeometryNode
 {
 public:
-    WaylandSurfaceNode(WaylandSurfaceItem *item = 0);
-    ~WaylandSurfaceNode();
+    QWaylandSurfaceNode(QWaylandSurfaceItem *item = 0);
+    ~QWaylandSurfaceNode();
 
     void preprocess();
     void updateTexture();
@@ -68,21 +70,23 @@ public:
     bool isTextureUpdated() const { return m_textureUpdated; }
     void setTextureUpdated(bool textureUpdated) { m_textureUpdated = textureUpdated; }
 
-    WaylandSurfaceItem *item() const { return m_item; }
-    void setItem(WaylandSurfaceItem *item);
+    QWaylandSurfaceItem *item() const { return m_item; }
+    void setItem(QWaylandSurfaceItem *item);
 
 private:
 
-    WaylandSurfaceItem *m_item;
+    QWaylandSurfaceItem *m_item;
     bool m_textureUpdated;
     bool m_useTextureAlpha;
 
     QSGGeometry m_geometry;
-    QSGSimpleMaterial<WaylandSurfaceTextureState> *m_textureMaterial;
-    QSGSimpleMaterial<WaylandSurfaceTextureState> *m_opaqueTextureMaterial;
-    QSGSimpleMaterial<WaylandSurfaceTextureState> *m_currentMaterial;
+    QSGSimpleMaterial<QWaylandSurfaceTextureState> *m_textureMaterial;
+    QSGSimpleMaterial<QWaylandSurfaceTextureState> *m_opaqueTextureMaterial;
+    QSGSimpleMaterial<QWaylandSurfaceTextureState> *m_currentMaterial;
 
     QRectF m_rect;
 };
 
-#endif // WAYLANDSURFACENODE_H
+QT_END_NAMESPACE
+
+#endif // QWAYLANDSURFACENODE_H
diff --git a/src/compositor/compositor_api/waylandsurfacetexturematerial.cpp b/src/compositor/compositor_api/qwaylandsurfacetexturematerial.cpp
index 0ec8ccb48..9562457e2 100644
--- a/src/compositor/compositor_api/waylandsurfacetexturematerial.cpp
+++ b/src/compositor/compositor_api/qwaylandsurfacetexturematerial.cpp
@@ -39,9 +39,11 @@
 **
 ****************************************************************************/
 
-#include "waylandsurfacetexturematerial.h"
+#include "qwaylandsurfacetexturematerial_p.h"
 #include <QtGui/QOpenGLContext>
 
+QT_BEGIN_NAMESPACE
+
 static const char wayland_surface_texture_material_vertex[] =
            "uniform highp mat4 qt_Matrix;                      \n"
            "attribute highp vec4 qt_VertexPosition;            \n"
@@ -69,7 +71,7 @@ static const char wayland_surface_texture_material_fragment[] =
            "    gl_FragColor = texture2D(qt_Texture, qt_TexCoord) * qt_Opacity; \n"
            "}";
 
-QList<QByteArray> WaylandSurfaceTextureMaterial::attributes() const
+QList<QByteArray> QWaylandSurfaceTextureMaterial::attributes() const
 {
     QList<QByteArray> attributeList;
     attributeList << "qt_VertexPosition";
@@ -77,23 +79,23 @@ QList<QByteArray> WaylandSurfaceTextureMaterial::attributes() const
     return attributeList;
 }
 
-void WaylandSurfaceTextureMaterial::updateState(const WaylandSurfaceTextureState *newState, const WaylandSurfaceTextureState *oldState)
+void QWaylandSurfaceTextureMaterial::updateState(const QWaylandSurfaceTextureState *newState, const QWaylandSurfaceTextureState *oldState)
 {
     Q_UNUSED(oldState);
     newState->texture()->bind();
 }
 
-const char *WaylandSurfaceTextureMaterial::vertexShader() const
+const char *QWaylandSurfaceTextureMaterial::vertexShader() const
 {
     return wayland_surface_texture_material_vertex;
 }
 
-const char *WaylandSurfaceTextureMaterial::fragmentShader() const
+const char *QWaylandSurfaceTextureMaterial::fragmentShader() const
 {
     return wayland_surface_texture_material_fragment;
 }
 
-QList<QByteArray> WaylandSurfaceTextureOpaqueMaterial::attributes() const
+QList<QByteArray> QWaylandSurfaceTextureOpaqueMaterial::attributes() const
 {
     QList<QByteArray> attributeList;
     attributeList << "qt_VertexPosition";
@@ -101,18 +103,20 @@ QList<QByteArray> WaylandSurfaceTextureOpaqueMaterial::attributes() const
     return attributeList;
 }
 
-void WaylandSurfaceTextureOpaqueMaterial::updateState(const WaylandSurfaceTextureState *newState, const WaylandSurfaceTextureState *oldState)
+void QWaylandSurfaceTextureOpaqueMaterial::updateState(const QWaylandSurfaceTextureState *newState, const QWaylandSurfaceTextureState *oldState)
 {
     Q_UNUSED(oldState);
     newState->texture()->bind();
 }
 
-const char *WaylandSurfaceTextureOpaqueMaterial::vertexShader() const
+const char *QWaylandSurfaceTextureOpaqueMaterial::vertexShader() const
 {
     return wayland_surface_texture_material_vertex;
 }
 
-const char *WaylandSurfaceTextureOpaqueMaterial::fragmentShader() const
+const char *QWaylandSurfaceTextureOpaqueMaterial::fragmentShader() const
 {
     return wayland_surface_texture_opaque_material_fragment;
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/waylandsurfacetexturematerial.h b/src/compositor/compositor_api/qwaylandsurfacetexturematerial_p.h
index 4f5b66a3a..4cf3df093 100644
--- a/src/compositor/compositor_api/waylandsurfacetexturematerial.h
+++ b/src/compositor/compositor_api/qwaylandsurfacetexturematerial_p.h
@@ -39,16 +39,18 @@
 **
 ****************************************************************************/
 
-#ifndef WAYLANDSURFACETEXTUREMATERIAL_H
-#define WAYLANDSURFACETEXTUREMATERIAL_H
+#ifndef QWAYLANDSURFACETEXTUREMATERIAL_H
+#define QWAYLANDSURFACETEXTUREMATERIAL_H
 
 #include <QtQuick/QSGSimpleMaterial>
 #include <QtQuick/QSGTexture>
 #include <QtGui/QOpenGLFunctions>
 
-class WaylandSurfaceTextureState {
+QT_BEGIN_NAMESPACE
+
+class QWaylandSurfaceTextureState {
 public:
-    WaylandSurfaceTextureState()
+    QWaylandSurfaceTextureState()
         : m_texture(0)
     {}
     void setTexture(QSGTexture *texture) { m_texture = texture; }
@@ -58,30 +60,32 @@ private:
     QSGTexture *m_texture;
 };
 
-class WaylandSurfaceTextureMaterial : public QSGSimpleMaterialShader<WaylandSurfaceTextureState>
+class QWaylandSurfaceTextureMaterial : public QSGSimpleMaterialShader<QWaylandSurfaceTextureState>
 {
-    QSG_DECLARE_SIMPLE_SHADER(WaylandSurfaceTextureMaterial, WaylandSurfaceTextureState)
+    QSG_DECLARE_SIMPLE_SHADER(QWaylandSurfaceTextureMaterial, QWaylandSurfaceTextureState)
     public:
 
         QList<QByteArray> attributes() const;
 
-        void updateState(const WaylandSurfaceTextureState *newState, const WaylandSurfaceTextureState *oldState);
+        void updateState(const QWaylandSurfaceTextureState *newState, const QWaylandSurfaceTextureState *oldState);
 protected:
         const char *vertexShader() const;
         const char *fragmentShader() const;
 };
 
-class WaylandSurfaceTextureOpaqueMaterial : public QSGSimpleMaterialShader<WaylandSurfaceTextureState>
+class QWaylandSurfaceTextureOpaqueMaterial : public QSGSimpleMaterialShader<QWaylandSurfaceTextureState>
 {
-    QSG_DECLARE_SIMPLE_SHADER(WaylandSurfaceTextureOpaqueMaterial, WaylandSurfaceTextureState)
+    QSG_DECLARE_SIMPLE_SHADER(QWaylandSurfaceTextureOpaqueMaterial, QWaylandSurfaceTextureState)
     public:
 
         QList<QByteArray> attributes() const;
 
-        void updateState(const WaylandSurfaceTextureState *newState, const WaylandSurfaceTextureState *oldState);
+        void updateState(const QWaylandSurfaceTextureState *newState, const QWaylandSurfaceTextureState *oldState);
 protected:
         const char *vertexShader() const;
         const char *fragmentShader() const;
 };
 
-#endif // WAYLANDSURFACETEXTUREMATERIAL_H
+QT_END_NAMESPACE
+
+#endif // QWAYLANDSURFACETEXTUREMATERIAL_H
diff --git a/src/compositor/global/global.pri b/src/compositor/global/global.pri
index 4dcbe340e..f187619e5 100644
--- a/src/compositor/global/global.pri
+++ b/src/compositor/global/global.pri
@@ -1,10 +1,10 @@
-INCLUDEPATH += $$PWD
+INCLUDEPATH += global/
 
 HEADERS += \
-    $$PWD/waylandexport.h \
-    $$PWD/waylandobject.h \
-    $$PWD/waylandresourcecollection.h \
+    global/qwaylandexport.h \
+    global/qwaylandobject.h \
+    global/qwaylandresourcecollection.h
 
 SOURCES += \
-    $$PWD/waylandresourcecollection.cpp \
+    global/qwaylandresourcecollection.cpp
 
diff --git a/src/compositor/global/waylandexport.h b/src/compositor/global/qwaylandexport.h
index 7d1685b31..4998f836f 100644
--- a/src/compositor/global/waylandexport.h
+++ b/src/compositor/global/qwaylandexport.h
@@ -43,6 +43,8 @@
 
 #include <QtCore/qglobal.h>
 
+QT_BEGIN_NAMESPACE
+
 #if !defined(Q_COMPOSITOR_EXPORT)
 #  if defined(QT_SHARED)
 #    define Q_COMPOSITOR_EXPORT Q_DECL_EXPORT
@@ -53,4 +55,6 @@
 
 typedef void WaylandClient;
 
+QT_END_NAMESPACE
+
 #endif //WAYLANDEXPORT_H
diff --git a/src/compositor/global/waylandobject.h b/src/compositor/global/qwaylandobject.h
index 3f735fda2..6d93297a1 100644
--- a/src/compositor/global/waylandobject.h
+++ b/src/compositor/global/qwaylandobject.h
@@ -42,10 +42,13 @@
 #define WAYLAND_OBJECT_H
 
 #include <wayland-server.h>
-
 #include <string.h>
 
-namespace Wayland {
+#include <QtCompositor/qwaylandexport.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 template <typename T>
 class Object : public T
@@ -91,4 +94,6 @@ T *wayland_cast(typename T::Base *from)
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WAYLAND_OBJECT_H
diff --git a/src/compositor/global/waylandresourcecollection.cpp b/src/compositor/global/qwaylandresourcecollection.cpp
index 0f57750fc..6433474a3 100644
--- a/src/compositor/global/waylandresourcecollection.cpp
+++ b/src/compositor/global/qwaylandresourcecollection.cpp
@@ -38,11 +38,13 @@
 **
 ****************************************************************************/
 
-#include "waylandresourcecollection.h"
+#include "qwaylandresourcecollection.h"
 
 #include <QtCore/qglobal.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 ResourceCollection::ResourceCollection()
 {
@@ -86,5 +88,6 @@ void ResourceCollection::destroy_listener_notify(struct wl_listener *listener, v
     delete listener;
 }
 
-
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/global/waylandresourcecollection.h b/src/compositor/global/qwaylandresourcecollection.h
index 8bcc5bd2b..cfc1c32cb 100644
--- a/src/compositor/global/waylandresourcecollection.h
+++ b/src/compositor/global/qwaylandresourcecollection.h
@@ -43,7 +43,11 @@
 
 #include <wayland-server.h>
 
-namespace Wayland {
+#include <QtCompositor/qwaylandexport.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class ResourceCollection
 {
@@ -62,4 +66,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WAYLAND_RESOURCE_OBJECT_H
diff --git a/src/compositor/hardware_integration/hardware_integration.pri b/src/compositor/hardware_integration/hardware_integration.pri
index 352dbaee6..8477243fe 100644
--- a/src/compositor/hardware_integration/hardware_integration.pri
+++ b/src/compositor/hardware_integration/hardware_integration.pri
@@ -4,21 +4,16 @@ isEmpty(QT_WAYLAND_GL_CONFIG):QT_WAYLAND_GL_CONFIG = $$(QT_WAYLAND_GL_CONFIG)
 
 !isEqual(QT_WAYLAND_GL_CONFIG,nogl) {
     HEADERS += \
-        $$PWD/graphicshardwareintegration.h
+        hardware_integration/qwaylandgraphicshardwareintegration.h \
+        hardware_integration/qwaylandgraphicshardwareintegrationfactory.h \
+        hardware_integration/qwaylandgraphicshardwareintegrationplugin.h
 
     SOURCES += \
-        $$PWD/graphicshardwareintegration.cpp
+        hardware_integration/qwaylandgraphicshardwareintegration.cpp \
+        hardware_integration/qwaylandgraphicshardwareintegrationfactory.cpp \
+        hardware_integration/qwaylandgraphicshardwareintegrationplugin.cpp
 
     DEFINES += QT_COMPOSITOR_WAYLAND_GL
 } else {
     system(echo "Qt-Compositor configured as raster only compositor")
 }
-
-HEADERS += \
-    hardware_integration/graphicshardwareintegrationplugin.h \
-    hardware_integration/graphicshardwareintegrationfactory.h
-
-SOURCES += \
-    hardware_integration/graphicshardwareintegrationplugin.cpp \
-    hardware_integration/graphicshardwareintegrationfactory.cpp
-
diff --git a/src/compositor/hardware_integration/graphicshardwareintegration.cpp b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegration.cpp
index 13b460d71..7b213bfa5 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegration.cpp
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegration.cpp
@@ -38,9 +38,13 @@
 **
 ****************************************************************************/
 
-#include "graphicshardwareintegration.h"
+#include "qwaylandgraphicshardwareintegration.h"
 
-GraphicsHardwareIntegration::GraphicsHardwareIntegration()
+QT_BEGIN_NAMESPACE
+
+QWaylandGraphicsHardwareIntegration::QWaylandGraphicsHardwareIntegration()
     : m_compositor(0)
 {
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/hardware_integration/graphicshardwareintegration.h b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegration.h
index f6c46debf..373880440 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegration.h
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegration.h
@@ -45,18 +45,23 @@
 #include <QtGui/QOpenGLContext>
 #include <wayland-server.h>
 
-#include <QtCompositor/waylandcompositor.h>
-#include <QtCompositor/wldisplay.h>
+#include <QtCompositor/qwaylandcompositor.h>
 
-class Q_COMPOSITOR_EXPORT GraphicsHardwareIntegration
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
+    class Display;
+}
+
+class Q_COMPOSITOR_EXPORT QWaylandGraphicsHardwareIntegration
 {
 public:
-    GraphicsHardwareIntegration();
-    virtual ~GraphicsHardwareIntegration() { }
+    QWaylandGraphicsHardwareIntegration();
+    virtual ~QWaylandGraphicsHardwareIntegration() { }
 
-    void setCompositor(WaylandCompositor *compositor) { m_compositor = compositor; }
+    void setCompositor(QWaylandCompositor *compositor) { m_compositor = compositor; }
 
-    virtual void initializeHardware(Wayland::Display *waylandDisplay) = 0;
+    virtual void initializeHardware(QtWayland::Display *waylandDisplay) = 0;
 
     /** Bind the Wayland buffer to the textureId. The correct context is the current context,
         so there is no need to do makeCurrent in this function.
@@ -64,13 +69,15 @@ public:
     virtual GLuint createTextureFromBuffer(struct wl_buffer *buffer, QOpenGLContext *context) = 0;
     virtual bool isYInverted(struct wl_buffer *) const { return true; }
 
-    virtual bool setDirectRenderSurface(WaylandSurface *) {return false;}
+    virtual bool setDirectRenderSurface(QWaylandSurface *) {return false;}
 
     virtual void *lockNativeBuffer(struct wl_buffer *, QOpenGLContext *) const { return 0; }
     virtual void unlockNativeBuffer(void *, QOpenGLContext *) const { return; }
 
 protected:
-    WaylandCompositor *m_compositor;
+    QWaylandCompositor *m_compositor;
 };
 
+QT_END_NAMESPACE
+
 #endif // GRAPHICSHARDWAREINTEGRATION_H
diff --git a/src/compositor/hardware_integration/graphicshardwareintegrationfactory.cpp b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationfactory.cpp
index d8337c6e5..17e2dbdbe 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegrationfactory.cpp
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationfactory.cpp
@@ -39,21 +39,23 @@
 **
 ****************************************************************************/
 
-#include "graphicshardwareintegrationfactory.h"
-#include "graphicshardwareintegrationplugin.h"
-#include "graphicshardwareintegration.h"
+#include "qwaylandgraphicshardwareintegrationfactory.h"
+#include "qwaylandgraphicshardwareintegrationplugin.h"
+#include "qwaylandgraphicshardwareintegration.h"
 #include <QtCore/private/qfactoryloader_p.h>
 #include <QtCore/QCoreApplication>
 #include <QtCore/QDir>
 
+QT_BEGIN_NAMESPACE
+
 #ifndef QT_NO_LIBRARY
 Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
-    (GraphicsHardwareIntegrationFactoryInterface_iid, QLatin1String("/waylandcompositors"), Qt::CaseInsensitive))
+    (QWaylandGraphicsHardwareIntegrationFactoryInterface_iid, QLatin1String("/waylandcompositors"), Qt::CaseInsensitive))
 Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, directLoader,
-                          (GraphicsHardwareIntegrationFactoryInterface_iid, QLatin1String(""), Qt::CaseInsensitive))
+                          (QWaylandGraphicsHardwareIntegrationFactoryInterface_iid, QLatin1String(""), Qt::CaseInsensitive))
 #endif
 
-QStringList GraphicsHardwareIntegrationFactory::keys(const QString &pluginPath)
+QStringList QWaylandGraphicsHardwareIntegrationFactory::keys(const QString &pluginPath)
 {
 #ifndef QT_NO_LIBRARY
     QStringList list;
@@ -76,17 +78,19 @@ QStringList GraphicsHardwareIntegrationFactory::keys(const QString &pluginPath)
 #endif
 }
 
-GraphicsHardwareIntegration *GraphicsHardwareIntegrationFactory::create(const QString &name, const QStringList &args, const QString &pluginPath)
+QWaylandGraphicsHardwareIntegration *QWaylandGraphicsHardwareIntegrationFactory::create(const QString &name, const QStringList &args, const QString &pluginPath)
 {
 #ifndef QT_NO_LIBRARY
     // Try loading the plugin from platformPluginPath first:
     if (!pluginPath.isEmpty()) {
         QCoreApplication::addLibraryPath(pluginPath);
-        if (GraphicsHardwareIntegration *ret = qLoadPlugin1<GraphicsHardwareIntegration, GraphicsHardwareIntegrationPlugin>(directLoader(), name, args))
+        if (QWaylandGraphicsHardwareIntegration *ret = qLoadPlugin1<QWaylandGraphicsHardwareIntegration, QWaylandGraphicsHardwareIntegrationPlugin>(directLoader(), name, args))
             return ret;
     }
-    if (GraphicsHardwareIntegration *ret = qLoadPlugin1<GraphicsHardwareIntegration, GraphicsHardwareIntegrationPlugin>(loader(), name, args))
+    if (QWaylandGraphicsHardwareIntegration *ret = qLoadPlugin1<QWaylandGraphicsHardwareIntegration, QWaylandGraphicsHardwareIntegrationPlugin>(loader(), name, args))
         return ret;
 #endif
     return 0;
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/hardware_integration/graphicshardwareintegrationfactory.h b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationfactory.h
index 22bcd09cf..74e5dda0c 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegrationfactory.h
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationfactory.h
@@ -42,16 +42,20 @@
 #ifndef GRAPHICSHARDWAREINTEGRATIONFACTORY_H
 #define GRAPHICSHARDWAREINTEGRATIONFACTORY_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 #include <QtCore/QStringList>
 
-class GraphicsHardwareIntegration;
+QT_BEGIN_NAMESPACE
 
-class Q_COMPOSITOR_EXPORT GraphicsHardwareIntegrationFactory
+class QWaylandGraphicsHardwareIntegration;
+
+class Q_COMPOSITOR_EXPORT QWaylandGraphicsHardwareIntegrationFactory
 {
 public:
     static QStringList keys(const QString &pluginPath = QString());
-    static GraphicsHardwareIntegration *create(const QString &name, const QStringList &args, const QString &pluginPath = QString());
+    static QWaylandGraphicsHardwareIntegration *create(const QString &name, const QStringList &args, const QString &pluginPath = QString());
 };
 
+QT_END_NAMESPACE
+
 #endif // GRAPHICSHARDWAREINTEGRATIONFACTORY_H
diff --git a/src/compositor/hardware_integration/graphicshardwareintegrationplugin.cpp b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationplugin.cpp
index 3bde8e8ab..66e07352e 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegrationplugin.cpp
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationplugin.cpp
@@ -39,14 +39,17 @@
 **
 ****************************************************************************/
 
-#include "graphicshardwareintegrationplugin.h"
+#include "qwaylandgraphicshardwareintegrationplugin.h"
 
-GraphicsHardwareIntegrationPlugin::GraphicsHardwareIntegrationPlugin(QObject *parent) :
+QT_BEGIN_NAMESPACE
+
+QWaylandGraphicsHardwareIntegrationPlugin::QWaylandGraphicsHardwareIntegrationPlugin(QObject *parent) :
     QObject(parent)
 {
 }
 
-GraphicsHardwareIntegrationPlugin::~GraphicsHardwareIntegrationPlugin()
+QWaylandGraphicsHardwareIntegrationPlugin::~QWaylandGraphicsHardwareIntegrationPlugin()
 {
 }
 
+QT_END_NAMESPACE
diff --git a/src/compositor/hardware_integration/graphicshardwareintegrationplugin.h b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationplugin.h
index 51f605164..6d68a0cc9 100644
--- a/src/compositor/hardware_integration/graphicshardwareintegrationplugin.h
+++ b/src/compositor/hardware_integration/qwaylandgraphicshardwareintegrationplugin.h
@@ -42,23 +42,27 @@
 #ifndef GRAPHICSHARDWAREINTEGRATIONPLUGIN_H
 #define GRAPHICSHARDWAREINTEGRATIONPLUGIN_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
 #include <QtCore/qplugin.h>
 #include <QtCore/qfactoryinterface.h>
 
-class GraphicsHardwareIntegration;
+QT_BEGIN_NAMESPACE
 
-#define GraphicsHardwareIntegrationFactoryInterface_iid "org.qt-project.Qt.Compositor.GraphicsHardwareIntegrationFactoryInterface.5.1"
+class QWaylandGraphicsHardwareIntegration;
 
-class Q_COMPOSITOR_EXPORT GraphicsHardwareIntegrationPlugin : public QObject
+#define QWaylandGraphicsHardwareIntegrationFactoryInterface_iid "org.qt-project.Qt.Compositor.QWaylandGraphicsHardwareIntegrationFactoryInterface.5.1"
+
+class Q_COMPOSITOR_EXPORT QWaylandGraphicsHardwareIntegrationPlugin : public QObject
 {
     Q_OBJECT
 public:
-    explicit GraphicsHardwareIntegrationPlugin(QObject *parent = 0);
-    ~GraphicsHardwareIntegrationPlugin();
+    explicit QWaylandGraphicsHardwareIntegrationPlugin(QObject *parent = 0);
+    ~QWaylandGraphicsHardwareIntegrationPlugin();
 
-    virtual GraphicsHardwareIntegration *create(const QString &key, const QStringList &paramList) = 0;
+    virtual QWaylandGraphicsHardwareIntegration *create(const QString &key, const QStringList &paramList) = 0;
 };
 
+QT_END_NAMESPACE
+
 #endif // GRAPHICSHARDWAREINTEGRATIONPLUGIN_H
diff --git a/src/compositor/wayland_wrapper/wlcompositor.cpp b/src/compositor/wayland_wrapper/qwlcompositor.cpp
index a0716f3b2..26defc0ba 100644
--- a/src/compositor/wayland_wrapper/wlcompositor.cpp
+++ b/src/compositor/wayland_wrapper/qwlcompositor.cpp
@@ -38,22 +38,23 @@
 **
 ****************************************************************************/
 
-#include "wlcompositor.h"
-
-#include "waylandinput.h"
-#include "wldisplay.h"
-#include "wlsurface.h"
-#include "waylandcompositor.h"
-#include "wldatadevicemanager.h"
-#include "wldatadevice.h"
-#include "wlextendedoutput.h"
-#include "wlextendedsurface.h"
-#include "wlsubsurface.h"
-#include "wlshellsurface.h"
-#include "wltouch.h"
-#include "wlqtkey.h"
-#include "wlinputdevice.h"
-#include "wlregion.h"
+#include "qwlcompositor_p.h"
+
+#include "qwaylandinput.h"
+#include "qwldisplay_p.h"
+#include "qwloutput_p.h"
+#include "qwlsurface_p.h"
+#include "qwaylandcompositor.h"
+#include "qwldatadevicemanager_p.h"
+#include "qwldatadevice_p.h"
+#include "qwlextendedoutput_p.h"
+#include "qwlextendedsurface_p.h"
+#include "qwlsubsurface_p.h"
+#include "qwlshellsurface_p.h"
+#include "qwltouch_p.h"
+#include "qwlqtkey_p.h"
+#include "qwlinputdevice_p.h"
+#include "qwlregion_p.h"
 
 #include <QWindow>
 #include <QSocketNotifier>
@@ -80,12 +81,14 @@
 
 #include <wayland-server.h>
 
-#include "hardware_integration/graphicshardwareintegration.h"
+#include "hardware_integration/qwaylandgraphicshardwareintegration.h"
 #include "waylandwindowmanagerintegration.h"
 
-#include "hardware_integration/graphicshardwareintegrationfactory.h"
+#include "hardware_integration/qwaylandgraphicshardwareintegrationfactory.h"
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 static Compositor *compositor;
 
@@ -119,7 +122,7 @@ Compositor *Compositor::instance()
     return compositor;
 }
 
-Compositor::Compositor(WaylandCompositor *qt_compositor)
+Compositor::Compositor(QWaylandCompositor *qt_compositor)
     : m_display(new Display)
     , m_default_input_device(0)
     , m_pageFlipper(0)
@@ -144,7 +147,7 @@ Compositor::Compositor(WaylandCompositor *qt_compositor)
 #if defined (QT_COMPOSITOR_WAYLAND_GL)
     QWindow *window = qt_compositor->window();
     if (window && window->surfaceType() != QWindow::RasterSurface) {
-        QStringList keys = GraphicsHardwareIntegrationFactory::keys();
+        QStringList keys = QWaylandGraphicsHardwareIntegrationFactory::keys();
         QString targetKey;
         QByteArray hardwareIntegration = qgetenv("QT_WAYLAND_HARDWARE_INTEGRATION");
         if (keys.contains(QString::fromLocal8Bit(hardwareIntegration.constData()))) {
@@ -156,7 +159,7 @@ Compositor::Compositor(WaylandCompositor *qt_compositor)
         }
 
         if (!targetKey.isEmpty()) {
-            m_graphics_hw_integration = GraphicsHardwareIntegrationFactory::create(targetKey, QStringList());
+            m_graphics_hw_integration = QWaylandGraphicsHardwareIntegrationFactory::create(targetKey, QStringList());
             if (m_graphics_hw_integration) {
                 m_graphics_hw_integration->setCompositor(qt_compositor);
             }
@@ -173,7 +176,8 @@ Compositor::Compositor(WaylandCompositor *qt_compositor)
 
     wl_display_init_shm(m_display->handle());
 
-    wl_display_add_global(m_display->handle(),&wl_output_interface, &m_output_global,OutputGlobal::output_bind_func);
+    m_output_global = new OutputGlobal();
+    wl_display_add_global(m_display->handle(),&wl_output_interface, m_output_global, OutputGlobal::output_bind_func);
 
     m_shell = new Shell();
     wl_display_add_global(m_display->handle(), &wl_shell_interface, m_shell, Shell::bind_func);
@@ -217,7 +221,7 @@ Compositor::~Compositor()
 #ifdef QT_COMPOSITOR_WAYLAND_GL
     delete m_graphics_hw_integration;
 #endif
-
+    delete m_output_global;
     delete m_display;
 }
 
@@ -317,7 +321,7 @@ void Compositor::surfaceDestroyed(Surface *surface)
     waylandCompositor()->surfaceAboutToBeDestroyed(surface->waylandSurface());
 }
 
-void Compositor::markSurfaceAsDirty(Wayland::Surface *surface)
+void Compositor::markSurfaceAsDirty(QtWayland::Surface *surface)
 {
     m_dirty_surfaces.insert(surface);
 }
@@ -341,7 +345,7 @@ QWindow *Compositor::window() const
     return m_qt_compositor->window();
 }
 
-GraphicsHardwareIntegration * Compositor::graphicsHWIntegration() const
+QWaylandGraphicsHardwareIntegration * Compositor::graphicsHWIntegration() const
 {
 #ifdef QT_COMPOSITOR_WAYLAND_GL
     return m_graphics_hw_integration;
@@ -360,7 +364,7 @@ void Compositor::initializeHardwareIntegration()
 
 void Compositor::initializeDefaultInputDevice()
 {
-    m_default_wayland_input_device = new WaylandInputDevice(m_qt_compositor);
+    m_default_wayland_input_device = new QWaylandInputDevice(m_qt_compositor);
     m_default_input_device = m_default_wayland_input_device->handle();
 }
 
@@ -420,7 +424,7 @@ QList<struct wl_client *> Compositor::clients() const
 
 Qt::ScreenOrientations Compositor::orientationUpdateMaskForClient(wl_client *client)
 {
-    Output *output = m_output_global.outputForClient(client);
+    Output *output = m_output_global->outputForClient(client);
     Q_ASSERT(output);
     if (output->extendedOutput())
         return output->extendedOutput()->orientationUpdateMask();
@@ -434,7 +438,7 @@ void Compositor::setScreenOrientation(Qt::ScreenOrientation orientation)
     QList<struct wl_client*> clientList = clients();
     for (int i = 0; i < clientList.length(); ++i) {
         struct wl_client *client = clientList.at(i);
-        Output *output = m_output_global.outputForClient(client);
+        Output *output = m_output_global->outputForClient(client);
         Q_ASSERT(output);
         if (output->extendedOutput()){
             output->extendedOutput()->sendOutputOrientation(orientation);
@@ -449,22 +453,28 @@ Qt::ScreenOrientation Compositor::screenOrientation() const
 
 void Compositor::setOutputGeometry(const QRect &geometry)
 {
-    m_output_global.setGeometry(geometry);
+    if (m_output_global)
+        m_output_global->setGeometry(geometry);
 }
 
 QRect Compositor::outputGeometry() const
 {
-    return m_output_global.geometry();
+    if (m_output_global)
+        return m_output_global->geometry();
+    return QRect();
 }
 
 void Compositor::setOutputRefreshRate(int rate)
 {
-    m_output_global.setRefreshRate(rate);
+    if (m_output_global)
+        m_output_global->setRefreshRate(rate);
 }
 
 int Compositor::outputRefreshRate() const
 {
-    return m_output_global.refreshRate();
+    if (m_output_global)
+        return m_output_global->refreshRate();
+    return 0;
 }
 
 void Compositor::setClientFullScreenHint(bool value)
@@ -477,9 +487,9 @@ InputDevice* Compositor::defaultInputDevice()
     return m_default_input_device;
 }
 
-QList<Wayland::Surface *> Compositor::surfacesForClient(wl_client *client)
+QList<QtWayland::Surface *> Compositor::surfacesForClient(wl_client *client)
 {
-    QList<Wayland::Surface *> ret;
+    QList<QtWayland::Surface *> ret;
 
     for (int i=0; i < m_surfaces.count(); ++i) {
         if (m_surfaces.at(i)->base()->resource.client == client) {
@@ -559,3 +569,5 @@ void Compositor::sendDragEndEvent()
 }
 
 } // namespace Wayland
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlcompositor.h b/src/compositor/wayland_wrapper/qwlcompositor_p.h
index a009037b5..628470681 100644
--- a/src/compositor/wayland_wrapper/wlcompositor.h
+++ b/src/compositor/wayland_wrapper/qwlcompositor_p.h
@@ -41,30 +41,32 @@
 #ifndef WL_COMPOSITOR_H
 #define WL_COMPOSITOR_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
 #include <QtCore/QSet>
 #include <QtGui/QWindow>
 
-#include "wloutput.h"
-#include "wldisplay.h"
+#include <private/qwldisplay_p.h>
 
 #include <wayland-server.h>
 
-class WaylandCompositor;
-class WaylandInputDevice;
-class GraphicsHardwareIntegration;
+QT_BEGIN_NAMESPACE
+
+class QWaylandCompositor;
+class QWaylandInputDevice;
+class QWaylandGraphicsHardwareIntegration;
 class WindowManagerServerIntegration;
 class QMimeData;
 class QPlatformScreenPageFlipper;
 class QPlatformScreenBuffer;
 
-namespace Wayland {
+namespace QtWayland {
 
 class Surface;
 class SurfaceBuffer;
 class InputDevice;
 class DataDeviceManager;
+class OutputGlobal;
 class OutputExtensionGlobal;
 class SurfaceExtensionGlobal;
 class SubSurfaceExtensionGlobal;
@@ -77,7 +79,7 @@ class Q_COMPOSITOR_EXPORT Compositor : public QObject
     Q_OBJECT
 
 public:
-    Compositor(WaylandCompositor *qt_compositor);
+    Compositor(QWaylandCompositor *qt_compositor);
     ~Compositor();
 
     void frameFinished(Surface *surface = 0);
@@ -99,7 +101,7 @@ public:
 
     QWindow *window() const;
 
-    GraphicsHardwareIntegration *graphicsHWIntegration() const;
+    QWaylandGraphicsHardwareIntegration *graphicsHWIntegration() const;
     void initializeHardwareIntegration();
     void initializeDefaultInputDevice();
     void initializeWindowManagerProtocol();
@@ -112,7 +114,7 @@ public:
 
     QList<Surface*> surfaces() const { return m_surfaces; }
     QList<Surface*> surfacesForClient(wl_client* client);
-    WaylandCompositor *waylandCompositor() const { return m_qt_compositor; }
+    QWaylandCompositor *waylandCompositor() const { return m_qt_compositor; }
 
     struct wl_display *wl_display() const { return m_display->handle(); }
 
@@ -162,12 +164,12 @@ private:
     Display *m_display;
 
     /* Input */
-    WaylandInputDevice *m_default_wayland_input_device;
+    QWaylandInputDevice *m_default_wayland_input_device;
     InputDevice *m_default_input_device;
 
     /* Output */
     //make this a list of the available screens
-    OutputGlobal m_output_global;
+    OutputGlobal *m_output_global;
     //This one should be part of the outputs
     QPlatformScreenPageFlipper *m_pageFlipper;
 
@@ -182,7 +184,7 @@ private:
 
     wl_event_loop *m_loop;
 
-    WaylandCompositor *m_qt_compositor;
+    QWaylandCompositor *m_qt_compositor;
     Qt::ScreenOrientation m_orientation;
 
     Surface *m_directRenderSurface;
@@ -190,7 +192,7 @@ private:
     bool m_directRenderActive;
 
 #ifdef QT_COMPOSITOR_WAYLAND_GL
-    GraphicsHardwareIntegration *m_graphics_hw_integration;
+    QWaylandGraphicsHardwareIntegration *m_graphics_hw_integration;
 #endif
 
     //extensions
@@ -212,4 +214,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WL_COMPOSITOR_H
diff --git a/src/compositor/wayland_wrapper/wldatadevice.cpp b/src/compositor/wayland_wrapper/qwldatadevice.cpp
index 2c3bc3801..89fa7a08e 100644
--- a/src/compositor/wayland_wrapper/wldatadevice.cpp
+++ b/src/compositor/wayland_wrapper/qwldatadevice.cpp
@@ -38,17 +38,19 @@
 **
 ****************************************************************************/
 
-#include "wldatadevice.h"
+#include "qwldatadevice_p.h"
 
-#include "wldatasource.h"
-#include "wldataoffer.h"
-#include "wldatadevicemanager.h"
+#include "qwldatasource_p.h"
+#include "qwldataoffer_p.h"
+#include "qwldatadevicemanager_p.h"
 
 #include <stdlib.h>
 
 #include <QDebug>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 void DataDevice::start_drag(struct wl_client *client,
                    struct wl_resource *resource,
@@ -125,3 +127,5 @@ struct wl_resource *DataDevice::dataDeviceResource() const
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wldatadevice.h b/src/compositor/wayland_wrapper/qwldatadevice_p.h
index 2f1d72f21..2b4acdc9d 100644
--- a/src/compositor/wayland_wrapper/wldatadevice.h
+++ b/src/compositor/wayland_wrapper/qwldatadevice_p.h
@@ -41,9 +41,11 @@
 #ifndef WLDATADEVICE_H
 #define WLDATADEVICE_H
 
-#include "wldatadevicemanager.h"
+#include <private/qwldatadevicemanager_p.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class DataSource;
 class DataDeviceManager;
@@ -79,4 +81,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLDATADEVICE_H
diff --git a/src/compositor/wayland_wrapper/wldatadevicemanager.cpp b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp
index cdfc0002b..f89dbc314 100644
--- a/src/compositor/wayland_wrapper/wldatadevicemanager.cpp
+++ b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp
@@ -38,14 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wldatadevicemanager.h"
-
-#include "wldatadevice.h"
-#include "wldatasource.h"
-#include "wlinputdevice.h"
-#include "wlcompositor.h"
-#include "wldataoffer.h"
-#include "wlsurface.h"
+#include "qwldatadevicemanager_p.h"
+
+#include "qwldatadevice_p.h"
+#include "qwldatasource_p.h"
+#include "qwlinputdevice_p.h"
+#include "qwlcompositor_p.h"
+#include "qwldataoffer_p.h"
+#include "qwlsurface_p.h"
 #include "qwaylandmimehelper.h"
 
 #include <QtCore/QDebug>
@@ -54,7 +54,9 @@
 #include <QtCore/private/qcore_unix_p.h>
 #include <QtCore/QFile>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 DataDeviceManager::DataDeviceManager(Compositor *compositor)
     : m_compositor(compositor)
@@ -302,3 +304,5 @@ const struct wl_data_offer_interface DataDeviceManager::compositor_offer_interfa
 };
 
 } //namespace
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wldatadevicemanager.h b/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h
index 5576a41f7..11510e63b 100644
--- a/src/compositor/wayland_wrapper/wldatadevicemanager.h
+++ b/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h
@@ -41,16 +41,18 @@
 #ifndef WLDATADEVICEMANAGER_H
 #define WLDATADEVICEMANAGER_H
 
-#include "wlcompositor.h"
+#include <private/qwlcompositor_p.h>
 
 #include <QtCore/QList>
 #include <QtCore/QMap>
 #include <QtGui/QClipboard>
 #include <QtCore/QMimeData>
 
+QT_BEGIN_NAMESPACE
+
 class QSocketNotifier;
 
-namespace Wayland {
+namespace QtWayland {
 
 class Compositor;
 
@@ -124,4 +126,7 @@ private:
 };
 
 }
+
+QT_END_NAMESPACE
+
 #endif // WLDATADEVICEMANAGER_H
diff --git a/src/compositor/wayland_wrapper/wldataoffer.cpp b/src/compositor/wayland_wrapper/qwldataoffer.cpp
index 80293a7d3..c2bfea35a 100644
--- a/src/compositor/wayland_wrapper/wldataoffer.cpp
+++ b/src/compositor/wayland_wrapper/qwldataoffer.cpp
@@ -38,9 +38,9 @@
 **
 ****************************************************************************/
 
-#include "wldataoffer.h"
+#include "qwldataoffer_p.h"
 
-#include "wldatadevice.h"
+#include "qwldatadevice_p.h"
 
 #include <wayland-server.h>
 
@@ -49,7 +49,9 @@
 
 #include <QtCore/QDebug>
 
-namespace Wayland
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland
 {
 
 DataOffer::DataOffer(DataSource *data_source)
@@ -113,5 +115,6 @@ void DataOffer::destroy(wl_client *client, wl_resource *resource)
     }
 }
 
-
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wldataoffer.h b/src/compositor/wayland_wrapper/qwldataoffer_p.h
index 4b47c977d..579434450 100644
--- a/src/compositor/wayland_wrapper/wldataoffer.h
+++ b/src/compositor/wayland_wrapper/qwldataoffer_p.h
@@ -41,11 +41,12 @@
 #ifndef WLDATAOFFER_H
 #define WLDATAOFFER_H
 
-#include "wldatasource.h"
+#include <private/qwldatasource_p.h>
+#include <QtCompositor/qwaylandresourcecollection.h>
 
-#include "waylandresourcecollection.h"
+QT_BEGIN_NAMESPACE
 
-namespace Wayland
+namespace QtWayland
 {
 
 class DataOffer : public ResourceCollection
@@ -75,4 +76,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLDATAOFFER_H
diff --git a/src/compositor/wayland_wrapper/wldatasource.cpp b/src/compositor/wayland_wrapper/qwldatasource.cpp
index d243f0a4b..271467f2e 100644
--- a/src/compositor/wayland_wrapper/wldatasource.cpp
+++ b/src/compositor/wayland_wrapper/qwldatasource.cpp
@@ -38,16 +38,18 @@
 **
 ****************************************************************************/
 
-#include "wldatasource.h"
-#include "wldataoffer.h"
-#include "wldatadevicemanager.h"
-#include "wlcompositor.h"
+#include "qwldatasource_p.h"
+#include "qwldataoffer_p.h"
+#include "qwldatadevicemanager_p.h"
+#include "qwlcompositor_p.h"
 
 #include <wayland-server-protocol.h>
 
 #include <QtCore/QDebug>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 DataSource::DataSource(struct wl_client *client, uint32_t id, uint32_t time)
     : m_time(time)
@@ -130,3 +132,5 @@ void DataSource::setManager(DataDeviceManager *mgr)
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wldatasource.h b/src/compositor/wayland_wrapper/qwldatasource_p.h
index 75e9bbdd6..be855d8da 100644
--- a/src/compositor/wayland_wrapper/wldatasource.h
+++ b/src/compositor/wayland_wrapper/qwldatasource_p.h
@@ -46,7 +46,9 @@
 #include <QtCore/QByteArray>
 #include <QtCore/QList>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class DataOffer;
 class DataDeviceManager;
@@ -87,4 +89,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLDATASOURCE_H
diff --git a/src/compositor/wayland_wrapper/wldisplay.cpp b/src/compositor/wayland_wrapper/qwldisplay.cpp
index e933e53e8..be5b54182 100644
--- a/src/compositor/wayland_wrapper/wldisplay.cpp
+++ b/src/compositor/wayland_wrapper/qwldisplay.cpp
@@ -38,13 +38,15 @@
 **
 ****************************************************************************/
 
-#include "wldisplay.h"
+#include "qwldisplay_p.h"
 
 #include <QtCore/QDebug>
 
 #include <wayland-server-protocol.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 Display::Display()
 {
@@ -60,3 +62,4 @@ Display::~Display()
 
 }
 
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wldisplay.h b/src/compositor/wayland_wrapper/qwldisplay_p.h
index 69cc93d07..f18cb1e6b 100644
--- a/src/compositor/wayland_wrapper/wldisplay.h
+++ b/src/compositor/wayland_wrapper/qwldisplay_p.h
@@ -42,8 +42,11 @@
 #define WL_DISPLAY_H
 
 #include <wayland-server.h>
+#include <QtCompositor/qwaylandexport.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class Display
 {
@@ -60,4 +63,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WL_DISPLAY_H
diff --git a/src/compositor/wayland_wrapper/wlextendedoutput.cpp b/src/compositor/wayland_wrapper/qwlextendedoutput.cpp
index b9182011a..8249f2721 100644
--- a/src/compositor/wayland_wrapper/wlextendedoutput.cpp
+++ b/src/compositor/wayland_wrapper/qwlextendedoutput.cpp
@@ -38,13 +38,15 @@
 **
 ****************************************************************************/
 
-#include "wlextendedoutput.h"
+#include "qwlextendedoutput_p.h"
 
-#include "wlcompositor.h"
-#include "wlsurface.h"
-#include "wloutput.h"
+#include "qwlcompositor_p.h"
+#include "qwlsurface_p.h"
+#include "qwloutput_p.h"
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 OutputExtensionGlobal::OutputExtensionGlobal(Compositor *compositor)
     : m_compositor(compositor)
@@ -144,5 +146,6 @@ void ExtendedOutput::sendOutputOrientation(Qt::ScreenOrientation orientation)
     wl_extended_output_send_set_screen_rotation(m_extended_output_resource, sendOpperation);
 }
 
-
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlextendedoutput.h b/src/compositor/wayland_wrapper/qwlextendedoutput_p.h
index 0d24a9245..46c56beb8 100644
--- a/src/compositor/wayland_wrapper/wlextendedoutput.h
+++ b/src/compositor/wayland_wrapper/qwlextendedoutput_p.h
@@ -44,9 +44,13 @@
 #include "wayland-server.h"
 #include "wayland-output-extension-server-protocol.h"
 
+#include <QtCompositor/qwaylandexport.h>
+
 #include <QtCore/qnamespace.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class Compositor;
 class Output;
@@ -93,4 +97,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLEXTENDEDOUTPUT_H
diff --git a/src/compositor/wayland_wrapper/wlextendedsurface.cpp b/src/compositor/wayland_wrapper/qwlextendedsurface.cpp
index 1ffb9c421..dd550af10 100644
--- a/src/compositor/wayland_wrapper/wlextendedsurface.cpp
+++ b/src/compositor/wayland_wrapper/qwlextendedsurface.cpp
@@ -38,12 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wlextendedsurface.h"
+#include "qwlextendedsurface_p.h"
 
-#include "wlcompositor.h"
-#include "wlsurface.h"
+#include "qwlcompositor_p.h"
+#include "qwlsurface_p.h"
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 SurfaceExtensionGlobal::SurfaceExtensionGlobal(Compositor *compositor)
     : m_compositor(compositor)
@@ -155,7 +157,7 @@ void ExtendedSurface::set_content_orientation(struct wl_client *client,
         emit extended_surface->m_surface->waylandSurface()->contentOrientationChanged();
 }
 
-void ExtendedSurface::setWindowFlags(WaylandSurface::WindowFlags flags)
+void ExtendedSurface::setWindowFlags(QWaylandSurface::WindowFlags flags)
 {
     if (flags == m_windowFlags)
         return;
@@ -186,7 +188,7 @@ void ExtendedSurface::set_window_flags(wl_client *client, wl_resource *resource,
 {
     Q_UNUSED(client);
     ExtendedSurface *extended_surface = static_cast<ExtendedSurface *>(resource->data);
-    extended_surface->setWindowFlags(WaylandSurface::WindowFlags(flags));
+    extended_surface->setWindowFlags(QWaylandSurface::WindowFlags(flags));
 }
 
 const struct wl_extended_surface_interface ExtendedSurface::extended_surface_interface = {
@@ -196,3 +198,5 @@ const struct wl_extended_surface_interface ExtendedSurface::extended_surface_int
 };
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlextendedsurface.h b/src/compositor/wayland_wrapper/qwlextendedsurface_p.h
index bb3192248..6dc60efb0 100644
--- a/src/compositor/wayland_wrapper/wlextendedsurface.h
+++ b/src/compositor/wayland_wrapper/qwlextendedsurface_p.h
@@ -44,15 +44,17 @@
 #include <wayland-server.h>
 #include "wayland-surface-extension-server-protocol.h"
 
-#include "wlsurface.h"
-#include "waylandsurface.h"
+#include <private/qwlsurface_p.h>
+#include <QtCompositor/qwaylandsurface.h>
 
 #include <QtCore/QVariant>
 #include <QtCore/QLinkedList>
 
-class WaylandSurface;
+QT_BEGIN_NAMESPACE
 
-namespace Wayland {
+class QWaylandSurface;
+
+namespace QtWayland {
 
 class Compositor;
 
@@ -87,11 +89,11 @@ public:
     void removeSubSurface(ExtendedSurface *subSurfaces);
     ExtendedSurface *parent() const;
     void setParent(ExtendedSurface *parent);
-    QLinkedList<WaylandSurface *> subSurfaces() const;
+    QLinkedList<QWaylandSurface *> subSurfaces() const;
 
     Qt::ScreenOrientation contentOrientation() const;
 
-    WaylandSurface::WindowFlags windowFlags() const { return m_windowFlags; }
+    QWaylandSurface::WindowFlags windowFlags() const { return m_windowFlags; }
 
     qint64 processId() const;
     void setProcessId(qint64 processId);
@@ -106,7 +108,7 @@ private:
 
     Qt::ScreenOrientation m_contentOrientation;
 
-    WaylandSurface::WindowFlags m_windowFlags;
+    QWaylandSurface::WindowFlags m_windowFlags;
 
     QByteArray m_authenticationToken;
     QVariantMap m_windowProperties;
@@ -124,11 +126,13 @@ private:
     static void set_window_flags(struct wl_client *client,
                                  struct wl_resource *resource,
                                  int32_t flags);
-    void setWindowFlags(WaylandSurface::WindowFlags flags);
+    void setWindowFlags(QWaylandSurface::WindowFlags flags);
 
     static const struct wl_extended_surface_interface extended_surface_interface;
 };
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLEXTENDEDSURFACE_H
diff --git a/src/compositor/wayland_wrapper/wlinputdevice.cpp b/src/compositor/wayland_wrapper/qwlinputdevice.cpp
index 6b8f36409..8591de254 100644
--- a/src/compositor/wayland_wrapper/wlinputdevice.cpp
+++ b/src/compositor/wayland_wrapper/qwlinputdevice.cpp
@@ -38,14 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wlinputdevice.h"
+#include "qwlinputdevice_p.h"
 
-#include "wlcompositor.h"
-#include "wldatadevice.h"
-#include "wlsurface.h"
-#include "wltouch.h"
-#include "wlqtkey.h"
-#include "waylandcompositor.h"
+#include "qwlcompositor_p.h"
+#include "qwldatadevice_p.h"
+#include "qwlsurface_p.h"
+#include "qwltouch_p.h"
+#include "qwlqtkey_p.h"
+#include "qwaylandcompositor.h"
 
 #include <QtGui/QTouchEvent>
 
@@ -60,9 +60,11 @@
 #include <stdlib.h>
 #endif
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
 
-InputDevice::InputDevice(WaylandInputDevice *handle, Compositor *compositor)
+namespace QtWayland {
+
+InputDevice::InputDevice(QWaylandInputDevice *handle, Compositor *compositor)
     : m_handle(handle)
     , m_compositor(compositor)
 {
@@ -245,7 +247,7 @@ void InputDevice::set_cursor(wl_client *client, wl_resource *resource,
 
     wl_pointer *pointer = reinterpret_cast<wl_pointer *>(resource->data);
     InputDevice *inputDevice = wayland_cast<InputDevice>(pointer->seat);
-    Wayland::Surface *surface = reinterpret_cast<Wayland::Surface *>(surface_resource->data);
+    QtWayland::Surface *surface = reinterpret_cast<QtWayland::Surface *>(surface_resource->data);
 
     surface->setCursorSurface(true);
     inputDevice->m_compositor->waylandCompositor()->setCursorSurface(surface->waylandSurface(), hotspot_x, hotspot_y);
@@ -599,7 +601,7 @@ Compositor *InputDevice::compositor() const
     return m_compositor;
 }
 
-WaylandInputDevice *InputDevice::handle() const
+QWaylandInputDevice *InputDevice::handle() const
 {
     return m_handle;
 }
@@ -644,3 +646,5 @@ DataDevice *InputDevice::dataDevice(struct wl_client *client) const
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlinputdevice.h b/src/compositor/wayland_wrapper/qwlinputdevice_p.h
index afd7ff51d..9365fa9de 100644
--- a/src/compositor/wayland_wrapper/wlinputdevice.h
+++ b/src/compositor/wayland_wrapper/qwlinputdevice_p.h
@@ -41,7 +41,7 @@
 #ifndef WLINPUTDEVICE_H
 #define WLINPUTDEVICE_H
 
-#include "waylandobject.h"
+#include <QtCompositor/qwaylandobject.h>
 
 #include <stdint.h>
 
@@ -52,11 +52,13 @@
 #include <xkbcommon/xkbcommon.h>
 #endif
 
+QT_BEGIN_NAMESPACE
+
 class QKeyEvent;
 class QTouchEvent;
-class WaylandInputDevice;
+class QWaylandInputDevice;
 
-namespace Wayland {
+namespace QtWayland {
 
 class Compositor;
 class DataDevice;
@@ -66,7 +68,7 @@ class DataDeviceManager;
 class InputDevice : public Object<struct wl_seat>
 {
 public:
-    InputDevice(WaylandInputDevice *handle, Compositor *compositor);
+    InputDevice(QWaylandInputDevice *handle, Compositor *compositor);
     ~InputDevice();
 
     void sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF());
@@ -96,7 +98,7 @@ public:
     void sendSelectionFocus(Surface *surface);
 
     Compositor *compositor() const;
-    WaylandInputDevice *handle() const;
+    QWaylandInputDevice *handle() const;
 
     wl_pointer *pointerDevice();
     wl_keyboard *keyboardDevice();
@@ -112,7 +114,7 @@ private:
     void updateModifierState(uint key, int state);
     void sendKeyModifiers(wl_resource *resource);
 
-    WaylandInputDevice *m_handle;
+    QWaylandInputDevice *m_handle;
     Compositor *m_compositor;
     QList<DataDevice *> m_data_devices;
     struct {
@@ -159,4 +161,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLINPUTDEVICE_H
diff --git a/src/compositor/wayland_wrapper/wloutput.cpp b/src/compositor/wayland_wrapper/qwloutput.cpp
index 33e86eee4..f248dccdb 100644
--- a/src/compositor/wayland_wrapper/wloutput.cpp
+++ b/src/compositor/wayland_wrapper/qwloutput.cpp
@@ -38,13 +38,15 @@
 **
 ****************************************************************************/
 
-#include "wloutput.h"
-#include "wlextendedoutput.h"
+#include "qwloutput_p.h"
+#include "qwlextendedoutput_p.h"
 #include <QGuiApplication>
 #include <QtGui/QScreen>
 #include <QRect>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 OutputGlobal::OutputGlobal()
     : m_displayId(-1)
@@ -122,3 +124,5 @@ wl_resource *Output::handle() const
 }
 
 } // namespace Wayland
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wloutput.h b/src/compositor/wayland_wrapper/qwloutput_p.h
index 8baf545f8..11341737d 100644
--- a/src/compositor/wayland_wrapper/wloutput.h
+++ b/src/compositor/wayland_wrapper/qwloutput_p.h
@@ -41,12 +41,14 @@
 #ifndef WL_OUTPUT_H
 #define WL_OUTPUT_H
 
-#include "waylandresourcecollection.h"
+#include <QtCompositor/qwaylandresourcecollection.h>
 
 #include <QtCore/QRect>
 #include <QtCore/QList>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class Output;
 class ExtendedOutput;
@@ -101,4 +103,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WL_OUTPUT_H
diff --git a/src/compositor/wayland_wrapper/wlqtkey.cpp b/src/compositor/wayland_wrapper/qwlqtkey.cpp
index a4948924b..a6fea9f2a 100644
--- a/src/compositor/wayland_wrapper/wlqtkey.cpp
+++ b/src/compositor/wayland_wrapper/qwlqtkey.cpp
@@ -38,12 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wlqtkey.h"
-#include "wlsurface.h"
+#include "qwlqtkey_p.h"
+#include "qwlsurface_p.h"
 #include <QKeyEvent>
 #include <QWindow>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 static void dummy(wl_client *, wl_resource *)
 {
@@ -111,3 +113,5 @@ bool QtKeyExtensionGlobal::postQtKeyEvent(QKeyEvent *event, Surface *surface)
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlqtkey.h b/src/compositor/wayland_wrapper/qwlqtkey_p.h
index d44e7c1bf..bb98f9b88 100644
--- a/src/compositor/wayland_wrapper/wlqtkey.h
+++ b/src/compositor/wayland_wrapper/qwlqtkey_p.h
@@ -41,15 +41,17 @@
 #ifndef WLQTKEY_H
 #define WLQTKEY_H
 
-#include "wlcompositor.h"
+#include  <private/qwlcompositor_p.h>
 #include "wayland-qtkey-extension-server-protocol.h"
 #include "wayland-util.h"
 
+QT_BEGIN_NAMESPACE
+
 class Compositor;
 class Surface;
 class QKeyEvent;
 
-namespace Wayland {
+namespace QtWayland {
 
 class QtKeyExtensionGlobal
 {
@@ -73,4 +75,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLQTKEY_H
diff --git a/src/compositor/wayland_wrapper/wlregion.cpp b/src/compositor/wayland_wrapper/qwlregion.cpp
index c4adcae49..c9e452528 100644
--- a/src/compositor/wayland_wrapper/wlregion.cpp
+++ b/src/compositor/wayland_wrapper/qwlregion.cpp
@@ -38,11 +38,13 @@
 **
 ****************************************************************************/
 
-#include "wlregion.h"
+#include "qwlregion_p.h"
 
-#include "wlcompositor.h"
+#include "qwlcompositor_p.h"
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 void destroy_region(struct wl_resource *resource)
 {
@@ -87,4 +89,4 @@ void Region::region_subtract(wl_client *client, wl_resource *region,
 
 }
 
-
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlregion.h b/src/compositor/wayland_wrapper/qwlregion_p.h
index 80a48ab1f..2002e7370 100644
--- a/src/compositor/wayland_wrapper/wlregion.h
+++ b/src/compositor/wayland_wrapper/qwlregion_p.h
@@ -41,14 +41,16 @@
 #ifndef WL_REGION_H
 #define WL_REGION_H
 
-#include "waylandexport.h"
-#include "waylandobject.h"
+#include <QtCompositor/qwaylandexport.h>
+#include <QtCompositor/qwaylandobject.h>
 
 #include <QRegion>
 
 #include <wayland-util.h>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class Q_COMPOSITOR_EXPORT Region : public Object<wl_resource>
 {
@@ -76,5 +78,7 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WL_REGION_H
 
diff --git a/src/compositor/wayland_wrapper/wlshellsurface.cpp b/src/compositor/wayland_wrapper/qwlshellsurface.cpp
index aed1ee64f..f8d6e0c5c 100644
--- a/src/compositor/wayland_wrapper/wlshellsurface.cpp
+++ b/src/compositor/wayland_wrapper/qwlshellsurface.cpp
@@ -38,17 +38,19 @@
 **
 ****************************************************************************/
 
-#include "wlshellsurface.h"
+#include "qwlshellsurface_p.h"
 
-#include "wlcompositor.h"
-#include "wlsurface.h"
-#include "wlinputdevice.h"
-#include "wlsubsurface.h"
+#include "qwlcompositor_p.h"
+#include "qwlsurface_p.h"
+#include "qwlinputdevice_p.h"
+#include "qwlsubsurface_p.h"
 
 #include <QtCore/qglobal.h>
 #include <QtCore/QDebug>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 Shell::Shell()
 {
@@ -471,3 +473,5 @@ const struct wl_pointer_grab_interface ShellSurfaceMoveGrabber::move_grabber_int
 };
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlshellsurface.h b/src/compositor/wayland_wrapper/qwlshellsurface_p.h
index e3a4713f1..1bb0c4e42 100644
--- a/src/compositor/wayland_wrapper/wlshellsurface.h
+++ b/src/compositor/wayland_wrapper/qwlshellsurface_p.h
@@ -41,12 +41,14 @@
 #ifndef WLSHELLSURFACE_H
 #define WLSHELLSURFACE_H
 
-#include "waylandobject.h"
+#include <QtCompositor/qwaylandobject.h>
 
 #include <wayland-server.h>
 #include <QPoint>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 class Compositor;
 class Surface;
@@ -193,8 +195,8 @@ public:
     static const struct wl_pointer_grab_interface move_grabber_interface;
 };
 
-
-
 }
 
+QT_END_NAMESPACE
+
 #endif // WLSHELLSURFACE_H
diff --git a/src/compositor/wayland_wrapper/wlsubsurface.cpp b/src/compositor/wayland_wrapper/qwlsubsurface.cpp
index c6013b65a..f482cde6d 100644
--- a/src/compositor/wayland_wrapper/wlsubsurface.cpp
+++ b/src/compositor/wayland_wrapper/qwlsubsurface.cpp
@@ -38,12 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wlsubsurface.h"
+#include "qwlsubsurface_p.h"
 
-#include "wlcompositor.h"
-#include "waylandsurface.h"
+#include "qwlcompositor_p.h"
+#include "qwaylandsurface.h"
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 SubSurfaceExtensionGlobal::SubSurfaceExtensionGlobal(Compositor *compositor)
     : m_compositor(compositor)
@@ -88,7 +90,7 @@ SubSurface::~SubSurface()
     if (m_parent) {
         m_parent->removeSubSurface(this);
     }
-    QLinkedList<WaylandSurface *>::iterator it;
+    QLinkedList<QWaylandSurface *>::iterator it;
     for (it = m_sub_surfaces.begin(); it != m_sub_surfaces.end(); ++it) {
         (*it)->handle()->subSurface()->parentDestroyed();
     }
@@ -119,8 +121,8 @@ void SubSurface::setParent(SubSurface *parent)
     if (m_parent == parent)
         return;
 
-    WaylandSurface *oldParent = 0;
-    WaylandSurface *newParent = 0;
+    QWaylandSurface *oldParent = 0;
+    QWaylandSurface *newParent = 0;
 
     if (m_parent) {
         oldParent = m_parent->m_surface->waylandSurface();
@@ -134,7 +136,7 @@ void SubSurface::setParent(SubSurface *parent)
     m_surface->waylandSurface()->parentChanged(newParent,oldParent);
 }
 
-QLinkedList<WaylandSurface *> SubSurface::subSurfaces() const
+QLinkedList<QWaylandSurface *> SubSurface::subSurfaces() const
 {
     return m_sub_surfaces;
 }
@@ -184,3 +186,5 @@ const struct wl_sub_surface_interface SubSurface::sub_surface_interface = {
 };
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlsubsurface.h b/src/compositor/wayland_wrapper/qwlsubsurface_p.h
index 6c7ede04e..4fb80d611 100644
--- a/src/compositor/wayland_wrapper/wlsubsurface.h
+++ b/src/compositor/wayland_wrapper/qwlsubsurface_p.h
@@ -41,16 +41,18 @@
 #ifndef WLSUBSURFACE_H
 #define WLSUBSURFACE_H
 
-#include "wlsurface.h"
+#include <private/qwlsurface_p.h>
 
 #include "wayland-sub-surface-extension-server-protocol.h"
 
 #include <QtCore/QLinkedList>
 
+QT_BEGIN_NAMESPACE
+
 class Compositor;
-class WaylandSurface;
+class QWaylandSurface;
 
-namespace Wayland {
+namespace QtWayland {
 
 class SubSurfaceExtensionGlobal
 {
@@ -82,10 +84,10 @@ public:
     SubSurface *parent() const;
     void setParent(SubSurface *parent);
 
-    QLinkedList<WaylandSurface *> subSurfaces() const;
+    QLinkedList<QWaylandSurface *> subSurfaces() const;
 
     Surface *surface() const;
-    WaylandSurface *waylandSurface() const;
+    QWaylandSurface *waylandSurface() const;
 
 private:
     void parentDestroyed();
@@ -93,7 +95,7 @@ private:
     Surface *m_surface;
 
     SubSurface *m_parent;
-    QLinkedList<WaylandSurface *> m_sub_surfaces;
+    QLinkedList<QWaylandSurface *> m_sub_surfaces;
 
     static void attach_sub_surface(struct wl_client *client,
                                    struct wl_resource *sub_surface_parent_resource,
@@ -119,12 +121,13 @@ inline Surface *SubSurface::surface() const
     return m_surface;
 }
 
-inline WaylandSurface *SubSurface::waylandSurface() const
+inline QWaylandSurface *SubSurface::waylandSurface() const
 {
     return m_surface->waylandSurface();
 }
 
-
 }
 
+QT_END_NAMESPACE
+
 #endif // WLSUBSURFACE_H
diff --git a/src/compositor/wayland_wrapper/wlsurface.cpp b/src/compositor/wayland_wrapper/qwlsurface.cpp
index 6781f29b9..e61b30fc1 100644
--- a/src/compositor/wayland_wrapper/wlsurface.cpp
+++ b/src/compositor/wayland_wrapper/qwlsurface.cpp
@@ -38,20 +38,20 @@
 **
 ****************************************************************************/
 
-#include "wlsurface.h"
+#include "qwlsurface_p.h"
 
-#include "waylandsurface.h"
+#include "qwaylandsurface.h"
 #ifdef QT_COMPOSITOR_QUICK
-#include "waylandsurfaceitem.h"
+#include "qwaylandsurfaceitem.h"
 #endif
 
-#include "wlcompositor.h"
-#include "wlinputdevice.h"
-#include "wlextendedsurface.h"
-#include "wlregion.h"
-#include "wlsubsurface.h"
-#include "wlsurfacebuffer.h"
-#include "wlshellsurface.h"
+#include "qwlcompositor_p.h"
+#include "qwlinputdevice_p.h"
+#include "qwlextendedsurface_p.h"
+#include "qwlregion_p.h"
+#include "qwlsubsurface_p.h"
+#include "qwlsurfacebuffer_p.h"
+#include "qwlshellsurface_p.h"
 
 #include <QtCore/QDebug>
 #include <QTouchEvent>
@@ -59,7 +59,7 @@
 #include <wayland-server.h>
 
 #ifdef QT_COMPOSITOR_WAYLAND_GL
-#include "hardware_integration/graphicshardwareintegration.h"
+#include "hardware_integration/qwaylandgraphicshardwareintegration.h"
 #include <qpa/qplatformopenglcontext.h>
 #endif
 
@@ -67,7 +67,9 @@
 #include "waylandwindowmanagerintegration.h"
 #endif
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 void destroy_surface(struct wl_resource *resource)
 {
@@ -78,7 +80,7 @@ void destroy_surface(struct wl_resource *resource)
 
 Surface::Surface(struct wl_client *client, uint32_t id, Compositor *compositor)
     : m_compositor(compositor)
-    , m_waylandSurface(new WaylandSurface(this))
+    , m_waylandSurface(new QWaylandSurface(this))
     , m_backBuffer(0)
     , m_frontBuffer(0)
     , m_surfaceMapped(false)
@@ -109,30 +111,30 @@ Surface::~Surface()
     }
 }
 
-WaylandSurface::Type Surface::type() const
+QWaylandSurface::Type Surface::type() const
 {
     SurfaceBuffer *surfaceBuffer = currentSurfaceBuffer();
     if (surfaceBuffer && surfaceBuffer->waylandBufferHandle()) {
         if (surfaceBuffer->isShmBuffer()) {
-            return WaylandSurface::Shm;
+            return QWaylandSurface::Shm;
         } else {
-            return WaylandSurface::Texture;
+            return QWaylandSurface::Texture;
         }
     }
-    return WaylandSurface::Invalid;
+    return QWaylandSurface::Invalid;
 }
 
 bool Surface::isYInverted() const
 {
     bool ret = false;
     static bool negateReturn = qgetenv("QT_COMPOSITOR_NEGATE_INVERTED_Y").toInt();
-    GraphicsHardwareIntegration *graphicsHWIntegration = m_compositor->graphicsHWIntegration();
+    QWaylandGraphicsHardwareIntegration *graphicsHWIntegration = m_compositor->graphicsHWIntegration();
 
 #ifdef QT_COMPOSITOR_WAYLAND_GL
     SurfaceBuffer *surfacebuffer = currentSurfaceBuffer();
     if (!surfacebuffer) {
         ret = false;
-    } else if (graphicsHWIntegration && surfacebuffer->waylandBufferHandle() && type() != WaylandSurface::Shm) {
+    } else if (graphicsHWIntegration && surfacebuffer->waylandBufferHandle() && type() != QWaylandSurface::Shm) {
         ret = graphicsHWIntegration->isYInverted(surfacebuffer->waylandBufferHandle());
     } else
 #endif
@@ -197,7 +199,7 @@ QRegion Surface::opaqueRegion() const
 QImage Surface::image() const
 {
     SurfaceBuffer *surfacebuffer = currentSurfaceBuffer();
-    if (surfacebuffer && !surfacebuffer->isDestroyed() && type() == WaylandSurface::Shm) {
+    if (surfacebuffer && !surfacebuffer->isDestroyed() && type() == QWaylandSurface::Shm) {
         struct wl_buffer *buffer = surfacebuffer->waylandBufferHandle();
         int stride = wl_shm_buffer_get_stride(buffer);
         uint format = wl_shm_buffer_get_format(buffer);
@@ -215,9 +217,9 @@ GLuint Surface::textureId(QOpenGLContext *context) const
 {
     const SurfaceBuffer *surfacebuffer = currentSurfaceBuffer();
 
-    if (m_compositor->graphicsHWIntegration() && type() == WaylandSurface::Texture
+    if (m_compositor->graphicsHWIntegration() && type() == QWaylandSurface::Texture
          && !surfacebuffer->textureCreated()) {
-        GraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
+        QWaylandGraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
         const_cast<SurfaceBuffer *>(surfacebuffer)->createTexture(hwIntegration,context);
     }
     return surfacebuffer->texture();
@@ -253,7 +255,7 @@ void Surface::frameFinished()
     m_compositor->frameFinished(this);
 }
 
-WaylandSurface * Surface::waylandSurface() const
+QWaylandSurface * Surface::waylandSurface() const
 {
     return m_waylandSurface;
 }
@@ -349,7 +351,7 @@ bool Surface::advanceBufferQueue()
 void Surface::doUpdate() {
     if (postBuffer()) {
 #ifdef QT_COMPOSITOR_QUICK
-        WaylandSurfaceItem *surfaceItem = waylandSurface()->surfaceItem();
+        QWaylandSurfaceItem *surfaceItem = waylandSurface()->surfaceItem();
         if (surfaceItem)
             surfaceItem->setDamagedFlag(true); // avoid flicker when we switch back to composited mode
 #endif
@@ -520,3 +522,4 @@ void Surface::setTitle(const QString &title)
 
 } // namespace Wayland
 
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlsurface.h b/src/compositor/wayland_wrapper/qwlsurface_p.h
index 5c11c6bc4..21b1ae742 100644
--- a/src/compositor/wayland_wrapper/wlsurface.h
+++ b/src/compositor/wayland_wrapper/qwlsurface_p.h
@@ -41,12 +41,12 @@
 #ifndef WL_SURFACE_H
 #define WL_SURFACE_H
 
-#include "waylandexport.h"
+#include <QtCompositor/qwaylandexport.h>
 
-#include "wlsurfacebuffer.h"
-#include "waylandsurface.h"
+#include <private/qwlsurfacebuffer_p.h>
+#include <QtCompositor/qwaylandsurface.h>
 
-#include "waylandobject.h"
+#include <QtCompositor/qwaylandobject.h>
 
 #include <QtCore/QRect>
 #include <QtGui/QImage>
@@ -61,9 +61,11 @@
 
 #include <wayland-util.h>
 
+QT_BEGIN_NAMESPACE
+
 class QTouchEvent;
 
-namespace Wayland {
+namespace QtWayland {
 
 class Compositor;
 class Buffer;
@@ -77,7 +79,7 @@ public:
     Surface(struct wl_client *client, uint32_t id, Compositor *compositor);
     ~Surface();
 
-    WaylandSurface::Type type() const;
+    QWaylandSurface::Type type() const;
     bool isYInverted() const;
 
     bool visible() const;
@@ -104,7 +106,7 @@ public:
 
     void frameFinished();
 
-    WaylandSurface *waylandSurface() const;
+    QWaylandSurface *waylandSurface() const;
 
     QPoint lastMousePos() const;
 
@@ -139,7 +141,7 @@ private:
     Q_DISABLE_COPY(Surface)
 
     Compositor *m_compositor;
-    WaylandSurface *m_waylandSurface;
+    QWaylandSurface *m_waylandSurface;
 
     SurfaceBuffer *m_backBuffer;
     SurfaceBuffer *m_frontBuffer;
@@ -199,4 +201,6 @@ inline SurfaceBuffer *Surface::currentSurfaceBuffer() const {
 
 }
 
+QT_END_NAMESPACE
+
 #endif //WL_SURFACE_H
diff --git a/src/compositor/wayland_wrapper/wlsurfacebuffer.cpp b/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp
index 6dd76532c..cebe105b8 100644
--- a/src/compositor/wayland_wrapper/wlsurfacebuffer.cpp
+++ b/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp
@@ -38,19 +38,21 @@
 **
 ****************************************************************************/
 
-#include "wlsurfacebuffer.h"
+#include "qwlsurfacebuffer_p.h"
 
-#include "wlsurface.h"
-#include "wlcompositor.h"
+#include "qwlsurface_p.h"
+#include "qwlcompositor_p.h"
 
 #ifdef QT_COMPOSITOR_WAYLAND_GL
-#include "hardware_integration/graphicshardwareintegration.h"
+#include "hardware_integration/qwaylandgraphicshardwareintegration.h"
 #include <qpa/qplatformopenglcontext.h>
 #endif
 
 #include <QtCore/QDebug>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 SurfaceBuffer::SurfaceBuffer(Surface *surface)
     : QPlatformScreenBuffer()
@@ -106,7 +108,7 @@ void SurfaceBuffer::destructBufferState()
                 delete static_cast<QImage *>(m_handle);
 #ifdef QT_COMPOSITOR_WAYLAND_GL
             } else {
-                GraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
+                QWaylandGraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
                 hwIntegration->unlockNativeBuffer(m_handle, m_compositor->directRenderContext());
 #endif
             }
@@ -217,7 +219,7 @@ void *SurfaceBuffer::handle() const
             that->m_handle = image;
 #ifdef QT_COMPOSITOR_WAYLAND_GL
         } else {
-            GraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
+            QWaylandGraphicsHardwareIntegration *hwIntegration = m_compositor->graphicsHWIntegration();
             that->m_handle = hwIntegration->lockNativeBuffer(m_buffer, m_compositor->directRenderContext());
 #endif
         }
@@ -241,7 +243,7 @@ void freeTexture(QOpenGLFunctions *, GLuint id)
     glDeleteTextures(1, &id);
 }
 
-void SurfaceBuffer::createTexture(GraphicsHardwareIntegration *hwIntegration, QOpenGLContext *context)
+void SurfaceBuffer::createTexture(QWaylandGraphicsHardwareIntegration *hwIntegration, QOpenGLContext *context)
 {
 #ifdef QT_COMPOSITOR_WAYLAND_GL
     m_texture = hwIntegration->createTextureFromBuffer(m_buffer, context);
@@ -253,3 +255,5 @@ void SurfaceBuffer::createTexture(GraphicsHardwareIntegration *hwIntegration, QO
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wlsurfacebuffer.h b/src/compositor/wayland_wrapper/qwlsurfacebuffer_p.h
index 8efab29c8..dda335444 100644
--- a/src/compositor/wayland_wrapper/wlsurfacebuffer.h
+++ b/src/compositor/wayland_wrapper/qwlsurfacebuffer_p.h
@@ -48,10 +48,12 @@
 
 #include <wayland-server.h>
 
-class GraphicsHardwareIntegration;
+QT_BEGIN_NAMESPACE
+
+class QWaylandGraphicsHardwareIntegration;
 class QOpenGLContext;
 
-namespace Wayland {
+namespace QtWayland {
 
 class Surface;
 class Compositor;
@@ -95,7 +97,7 @@ public:
 
     inline bool textureCreated() const { return m_texture; }
 
-    void createTexture(GraphicsHardwareIntegration *hwIntegration, QOpenGLContext *context);
+    void createTexture(QWaylandGraphicsHardwareIntegration *hwIntegration, QOpenGLContext *context);
     inline GLuint texture() const;
     void destroyTexture();
 
@@ -139,4 +141,6 @@ GLuint SurfaceBuffer::texture() const
 
 }
 
+QT_END_NAMESPACE
+
 #endif // SURFACEBUFFER_H
diff --git a/src/compositor/wayland_wrapper/wltouch.cpp b/src/compositor/wayland_wrapper/qwltouch.cpp
index 67efc110e..458c74bf9 100644
--- a/src/compositor/wayland_wrapper/wltouch.cpp
+++ b/src/compositor/wayland_wrapper/qwltouch.cpp
@@ -38,12 +38,14 @@
 **
 ****************************************************************************/
 
-#include "wltouch.h"
-#include "wlsurface.h"
+#include "qwltouch_p.h"
+#include "qwlsurface_p.h"
 #include <QTouchEvent>
 #include <QWindow>
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
 
 static void dummy(wl_client *, wl_resource *)
 {
@@ -174,3 +176,5 @@ bool TouchExtensionGlobal::postTouchEvent(QTouchEvent *event, Surface *surface)
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/wltouch.h b/src/compositor/wayland_wrapper/qwltouch_p.h
index 8a4eba008..09c9a0898 100644
--- a/src/compositor/wayland_wrapper/wltouch.h
+++ b/src/compositor/wayland_wrapper/qwltouch_p.h
@@ -41,15 +41,17 @@
 #ifndef WLTOUCH_H
 #define WLTOUCH_H
 
-#include "wlcompositor.h"
+#include <private/qwlcompositor_p.h>
 #include "wayland-touch-extension-server-protocol.h"
 #include "wayland-util.h"
 
+QT_BEGIN_NAMESPACE
+
 class Compositor;
 class Surface;
 class QTouchEvent;
 
-namespace Wayland {
+namespace QtWayland {
 
 class TouchExtensionGlobal
 {
@@ -78,4 +80,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif // WLTOUCH_H
diff --git a/src/compositor/wayland_wrapper/wayland_wrapper.pri b/src/compositor/wayland_wrapper/wayland_wrapper.pri
index 84008c6c2..9bfe957e2 100644
--- a/src/compositor/wayland_wrapper/wayland_wrapper.pri
+++ b/src/compositor/wayland_wrapper/wayland_wrapper.pri
@@ -1,53 +1,50 @@
 WAYLANDSOURCES += \
-                $$PWD/../../extensions/surface-extension.xml \
-                $$PWD/../../extensions/sub-surface-extension.xml \
-                $$PWD/../../extensions/output-extension.xml \
-                $$PWD/../../extensions/touch-extension.xml \
-                $$PWD/../../extensions/qtkey-extension.xml
-
+    ../extensions/surface-extension.xml \
+    ../extensions/sub-surface-extension.xml \
+    ../extensions/output-extension.xml \
+    ../extensions/touch-extension.xml \
+    ../extensions/qtkey-extension.xml \
+    ../extensions/windowmanager.xml
 
 HEADERS += \
-    $$PWD/wlcompositor.h \
-    $$PWD/wldisplay.h \
-    $$PWD/wloutput.h \
-    $$PWD/wlsurface.h \
-    $$PWD/wlshellsurface.h \
-    $$PWD/wlinputdevice.h \
-    $$PWD/wldatadevicemanager.h \
-    $$PWD/wldatadevice.h \
-    $$PWD/wldataoffer.h \
-    $$PWD/wldatasource.h \
-    $$PWD/wlextendedsurface.h \
-    $$PWD/wlextendedoutput.h \
-    $$PWD/wlsubsurface.h \
-    $$PWD/wltouch.h \
-    $$PWD/wlqtkey.h \
-    $$PWD/../../shared/qwaylandmimehelper.h \
-    $$PWD/wlsurfacebuffer.h \
-    $$PWD/wlregion.h
+    wayland_wrapper/qwlcompositor_p.h \
+    wayland_wrapper/qwldatadevice_p.h \
+    wayland_wrapper/qwldatadevicemanager_p.h \
+    wayland_wrapper/qwldataoffer_p.h \
+    wayland_wrapper/qwldatasource_p.h \
+    wayland_wrapper/qwldisplay_p.h \
+    wayland_wrapper/qwlextendedoutput_p.h \
+    wayland_wrapper/qwlextendedsurface_p.h \
+    wayland_wrapper/qwlinputdevice_p.h \
+    wayland_wrapper/qwloutput_p.h \
+    wayland_wrapper/qwlqtkey_p.h \
+    wayland_wrapper/qwlregion_p.h \
+    wayland_wrapper/qwlshellsurface_p.h \
+    wayland_wrapper/qwlsubsurface_p.h \
+    wayland_wrapper/qwlsurface_p.h \
+    wayland_wrapper/qwlsurfacebuffer_p.h \
+    wayland_wrapper/qwltouch_p.h
 
 SOURCES += \
-    $$PWD/wlcompositor.cpp \
-    $$PWD/wldisplay.cpp \
-    $$PWD/wloutput.cpp \
-    $$PWD/wlsurface.cpp \
-    $$PWD/wlshellsurface.cpp \
-    $$PWD/wlinputdevice.cpp \
-    $$PWD/wldatadevicemanager.cpp \
-    $$PWD/wldatadevice.cpp \
-    $$PWD/wldataoffer.cpp \
-    $$PWD/wldatasource.cpp \
-    $$PWD/wlextendedsurface.cpp \
-    $$PWD/wlextendedoutput.cpp \
-    $$PWD/wlsubsurface.cpp \
-    $$PWD/wltouch.cpp \
-    $$PWD/wlqtkey.cpp \
-    $$PWD/../../shared/qwaylandmimehelper.cpp \
-    $$PWD/wlsurfacebuffer.cpp \
-    $$PWD/wlregion.cpp
+    wayland_wrapper/qwlcompositor.cpp \
+    wayland_wrapper/qwldatadevice.cpp \
+    wayland_wrapper/qwldatadevicemanager.cpp \
+    wayland_wrapper/qwldataoffer.cpp \
+    wayland_wrapper/qwldatasource.cpp \
+    wayland_wrapper/qwldisplay.cpp \
+    wayland_wrapper/qwlextendedoutput.cpp \
+    wayland_wrapper/qwlextendedsurface.cpp \
+    wayland_wrapper/qwlinputdevice.cpp \
+    wayland_wrapper/qwloutput.cpp \
+    wayland_wrapper/qwlqtkey.cpp \
+    wayland_wrapper/qwlregion.cpp \
+    wayland_wrapper/qwlshellsurface.cpp \
+    wayland_wrapper/qwlsubsurface.cpp \
+    wayland_wrapper/qwlsurface.cpp \
+    wayland_wrapper/qwlsurfacebuffer.cpp \
+    wayland_wrapper/qwltouch.cpp
 
-INCLUDEPATH += $$PWD
-INCLUDEPATH += $$PWD/../../shared
+INCLUDEPATH += wayland_wrapper
 
 config_xkbcommon {
     !contains(QT_CONFIG, no-pkg-config) {
diff --git a/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.cpp b/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.cpp
index 80c159d5c..ea16da313 100644
--- a/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.cpp
+++ b/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.cpp
@@ -40,17 +40,19 @@
 
 #include "waylandwindowmanagerintegration.h"
 
-#include "wayland_wrapper/wldisplay.h"
-#include "wayland_wrapper/wlcompositor.h"
+#include "wayland_wrapper/qwldisplay_p.h"
+#include "wayland_wrapper/qwlcompositor_p.h"
 
-#include "compositor_api/waylandcompositor.h"
+#include "compositor_api/qwaylandcompositor.h"
 
 #include "wayland-server.h"
 #include "wayland-windowmanager-server-protocol.h"
 
 #include <QUrl>
 
-WindowManagerServerIntegration::WindowManagerServerIntegration(WaylandCompositor *compositor, QObject *parent)
+QT_BEGIN_NAMESPACE
+
+WindowManagerServerIntegration::WindowManagerServerIntegration(QWaylandCompositor *compositor, QObject *parent)
     : QObject(parent)
     , m_showIsFullScreen(false)
     , m_compositor(compositor)
@@ -62,7 +64,7 @@ WindowManagerServerIntegration::~WindowManagerServerIntegration()
     qDeleteAll(m_managedClients);
 }
 
-void WindowManagerServerIntegration::initialize(Wayland::Display *waylandDisplay)
+void WindowManagerServerIntegration::initialize(QtWayland::Display *waylandDisplay)
 {
     wl_display_add_global(waylandDisplay->handle(),&wl_windowmanager_interface,this,WindowManagerServerIntegration::bind_func);
 }
@@ -208,3 +210,5 @@ QByteArray WaylandManagedClient::authenticationToken() const
 {
     return m_authenticationToken;
 }
+
+QT_END_NAMESPACE
diff --git a/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.h b/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.h
index f261e37bd..afae39dcc 100644
--- a/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.h
+++ b/src/compositor/windowmanagerprotocol/waylandwindowmanagerintegration.h
@@ -41,8 +41,8 @@
 #ifndef WAYLANDWINDOWMANAGERINTEGRATION_H
 #define WAYLANDWINDOWMANAGERINTEGRATION_H
 
-#include "waylandexport.h"
-#include "waylandresourcecollection.h"
+#include <QtCompositor/qwaylandexport.h>
+#include <QtCompositor/qwaylandresourcecollection.h>
 
 #include <qwindowdefs.h>
 #include <stdint.h>
@@ -54,22 +54,24 @@
 struct wl_client;
 struct wl_object;
 
-namespace Wayland {
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
     class Display;
 }
 
 class WindowManagerObject;
 class WaylandManagedClient;
-class WaylandCompositor;
+class QWaylandCompositor;
 
-class Q_COMPOSITOR_EXPORT WindowManagerServerIntegration : public QObject, private Wayland::ResourceCollection
+class Q_COMPOSITOR_EXPORT WindowManagerServerIntegration : public QObject, private QtWayland::ResourceCollection
 {
     Q_OBJECT
 public:
-    WindowManagerServerIntegration(WaylandCompositor *compositor, QObject *parent = 0);
+    WindowManagerServerIntegration(QWaylandCompositor *compositor, QObject *parent = 0);
     ~WindowManagerServerIntegration();
 
-    void initialize(Wayland::Display *waylandDisplay);
+    void initialize(QtWayland::Display *waylandDisplay);
     void removeClient(wl_client *client);
 
     WaylandManagedClient *managedClient(wl_client *client) const;
@@ -86,7 +88,7 @@ private:
 
 private:
     bool m_showIsFullScreen;
-    WaylandCompositor *m_compositor;
+    QWaylandCompositor *m_compositor;
     QMap<wl_client*, WaylandManagedClient*> m_managedClients;
 
     static void bind_func(struct wl_client *client, void *data,
@@ -121,4 +123,6 @@ private:
     friend class WindowManagerServerIntegration;
 };
 
+QT_END_NAMESPACE
+
 #endif // WAYLANDWINDOWMANAGERINTEGRATION_H
diff --git a/src/compositor/windowmanagerprotocol/windowmanagerprotocol.pri b/src/compositor/windowmanagerprotocol/windowmanagerprotocol.pri
index 457080f5a..7b35c7b79 100644
--- a/src/compositor/windowmanagerprotocol/windowmanagerprotocol.pri
+++ b/src/compositor/windowmanagerprotocol/windowmanagerprotocol.pri
@@ -1,11 +1,9 @@
 INCLUDEPATH += $$PWD
 
-WAYLANDSOURCES += $$PWD/../../extensions/windowmanager.xml
-
 HEADERS += \
-    $$PWD/waylandwindowmanagerintegration.h \
+    windowmanagerprotocol/waylandwindowmanagerintegration.h
 
 SOURCES += \
-    $$PWD/waylandwindowmanagerintegration.cpp \
+    windowmanagerprotocol/waylandwindowmanagerintegration.cpp