Remove the QtWayland::Output class

and add QWaylandOutputPrivate. Also make sure no other class holds a
pointer to the QWaylandOutputPrivate but only to QWaylandOutput

Change-Id: I6c5914d5bf9b394c6fbd7e181e603076fbdc79d7

5 files changed, 475 insertions, 92 deletions

diff --git a/src/compositor/compositor_api/qwaylandoutput.cpp b/src/compositor/compositor_api/qwaylandoutput.cpp
index 5a77912d1..88f3a4e09 100644
--- a/src/compositor/compositor_api/qwaylandoutput.cpp
+++ b/src/compositor/compositor_api/qwaylandoutput.cpp
@@ -36,27 +36,180 @@
 ****************************************************************************/
 
 #include "qwaylandoutput.h"
+#include "qwaylandoutput_p.h"
 
 #include "qwaylandcompositor.h"
 #include "qwaylandview.h"
 
+#include <QtCompositor/private/qwaylandsurface_p.h>
+
 #include <QtCore/QCoreApplication>
 #include <QtCore/QtMath>
 #include <QtGui/QWindow>
 #include <QtGui/QExposeEvent>
 #include <private/qobject_p.h>
 
-#include "wayland_wrapper/qwloutput_p.h"
-
 QT_BEGIN_NAMESPACE
 
+static QtWaylandServer::wl_output::subpixel toWlSubpixel(const QWaylandOutput::Subpixel &value)
+{
+    switch (value) {
+    case QWaylandOutput::SubpixelUnknown:
+        return QtWaylandServer::wl_output::subpixel_unknown;
+    case QWaylandOutput::SubpixelNone:
+        return QtWaylandServer::wl_output::subpixel_none;
+    case QWaylandOutput::SubpixelHorizontalRgb:
+        return QtWaylandServer::wl_output::subpixel_horizontal_rgb;
+    case QWaylandOutput::SubpixelHorizontalBgr:
+        return QtWaylandServer::wl_output::subpixel_horizontal_bgr;
+    case QWaylandOutput::SubpixelVerticalRgb:
+        return QtWaylandServer::wl_output::subpixel_vertical_rgb;
+    case QWaylandOutput::SubpixelVerticalBgr:
+        return QtWaylandServer::wl_output::subpixel_vertical_bgr;
+    default:
+        break;
+    }
+
+    return QtWaylandServer::wl_output::subpixel_unknown;
+}
+
+static QtWaylandServer::wl_output::transform toWlTransform(const QWaylandOutput::Transform &value)
+{
+    switch (value) {
+    case QWaylandOutput::Transform90:
+        return QtWaylandServer::wl_output::transform_90;
+    case QWaylandOutput::Transform180:
+        return QtWaylandServer::wl_output::transform_180;
+    case QWaylandOutput::Transform270:
+        return QtWaylandServer::wl_output::transform_270;
+    case QWaylandOutput::TransformFlipped:
+        return QtWaylandServer::wl_output::transform_flipped;
+    case QWaylandOutput::TransformFlipped90:
+        return QtWaylandServer::wl_output::transform_flipped_90;
+    case QWaylandOutput::TransformFlipped180:
+        return QtWaylandServer::wl_output::transform_flipped_180;
+    case QWaylandOutput::TransformFlipped270:
+        return QtWaylandServer::wl_output::transform_flipped_270;
+    default:
+        break;
+    }
+
+    return QtWaylandServer::wl_output::transform_normal;
+}
+
+QWaylandOutputPrivate::QWaylandOutputPrivate(QWaylandCompositor *compositor, QWindow *window, const QString &manufacturer, const QString &model)
+    : QtWaylandServer::wl_output(compositor->display(), 2)
+    , compositor(compositor)
+    , outputSpace(Q_NULLPTR)
+    , window(window)
+    , manufacturer(manufacturer)
+    , model(model)
+    , subpixel(QWaylandOutput::SubpixelUnknown)
+    , transform(QWaylandOutput::TransformNormal)
+    , scaleFactor(1)
+    , sizeFollowsWindow(true)
+{
+    mode.size = window ? window->size() : QSize();
+    mode.refreshRate = 60;
+
+    qRegisterMetaType<QWaylandOutput::Mode>("WaylandOutput::Mode");
+}
+
+QWaylandOutputPrivate::~QWaylandOutputPrivate()
+{
+    Q_Q(QWaylandOutput);
+    if (outputSpace) {
+        outputSpace = Q_NULLPTR;
+        outputSpace->removeOutput(q);
+    }
+}
+
+void QWaylandOutputPrivate::output_bind_resource(Resource *resource)
+{
+    send_geometry(resource->handle,
+                  position.x(), position.y(),
+                  physicalSize.width(), physicalSize.height(),
+                  toWlSubpixel(subpixel), manufacturer, model,
+                  toWlTransform(transform));
+
+    send_mode(resource->handle, mode_current | mode_preferred,
+              mode.size.width(), mode.size.height(),
+              mode.refreshRate);
+
+    if (resource->version() >= 2) {
+        send_scale(resource->handle, scaleFactor);
+        send_done(resource->handle);
+    }
+}
+
+void QWaylandOutputPrivate::sendGeometryInfo()
+{
+    Q_FOREACH (Resource *resource, resourceMap().values()) {
+        send_geometry(resource->handle,
+                      position.x(), position.x(),
+                      physicalSize.width(), physicalSize.height(),
+                      toWlSubpixel(subpixel), manufacturer, model,
+                      toWlTransform(transform));
+        if (resource->version() >= 2)
+            send_done(resource->handle);
+    }
+}
+
+
+void QWaylandOutputPrivate::addView(QWaylandView *view)
+{
+    addView(view, view->surface());
+}
+
+void QWaylandOutputPrivate::addView(QWaylandView *view, QWaylandSurface *surface)
+{
+    for (int i = 0; i < surfaceViews.size(); i++) {
+        if (surface == surfaceViews.at(i).surface) {
+            if (!surfaceViews.at(i).views.contains(view)) {
+                surfaceViews[i].views.append(view);
+            }
+            return;
+        }
+    }
+
+    surfaceViews.append(QWaylandSurfaceViewMapper(surface,view));
+}
+
+void QWaylandOutputPrivate::removeView(QWaylandView *view)
+{
+    removeView(view, view->surface());
+}
+
+void QWaylandOutputPrivate::removeView(QWaylandView *view, QWaylandSurface *surface)
+{
+    Q_Q(QWaylandOutput);
+    for (int i = 0; i < surfaceViews.size(); i++) {
+        if (surface == surfaceViews.at(i).surface) {
+            bool removed = surfaceViews[i].views.removeOne(view);
+            if (surfaceViews.at(i).views.isEmpty() && removed) {
+                if (surfaceViews.at(i).has_entered)
+                    q->surfaceLeave(surface);
+                surfaceViews.remove(i);
+            }
+            return;
+        }
+    }
+    qWarning("%s Could not find view %p for surface %p to remove. Possible invalid state", Q_FUNC_INFO, view, surface);
+}
+
+void QWaylandOutputPrivate::updateSurfaceForView(QWaylandView *view, QWaylandSurface *newSurface, QWaylandSurface *oldSurface)
+{
+    if (newSurface == oldSurface)
+        return;
+    removeView(view, oldSurface);
+    addView(view, newSurface);
+}
+
 QWaylandOutput::QWaylandOutput(QWaylandOutputSpace *outputSpace, QWindow *window,
                                const QString &manufacturer, const QString &model)
-    : QObject()
-    , d_ptr(new QtWayland::Output(this, outputSpace, window))
+    : QObject(*new QWaylandOutputPrivate(outputSpace->compositor(), window, manufacturer, model))
 {
-    d_ptr->setManufacturer(manufacturer);
-    d_ptr->setModel(model);
+    setOutputSpace(outputSpace);
     QObject::connect(window, &QWindow::widthChanged, this, &QWaylandOutput::setWidth);
     QObject::connect(window, &QWindow::heightChanged, this, &QWaylandOutput::setHeight);
     QObject::connect(window, &QObject::destroyed, this, &QWaylandOutput::windowDestroyed);
@@ -64,32 +217,46 @@ QWaylandOutput::QWaylandOutput(QWaylandOutputSpace *outputSpace, QWindow *window
 
 QWaylandOutput::~QWaylandOutput()
 {
-    d_ptr->outputSpace()->removeOutput(this);
 }
 
 QWaylandOutput *QWaylandOutput::fromResource(wl_resource *resource)
 {
-    QtWayland::OutputResource *outputResource = static_cast<QtWayland::OutputResource *>(
-        QtWayland::Output::Resource::fromResource(resource));
-    if (!outputResource)
-        return Q_NULLPTR;
+    return static_cast<QWaylandOutputPrivate *>(QWaylandOutputPrivate::Resource::fromResource(resource)->output_object)->q_func();
+}
 
-    QtWayland::Output *output = static_cast<QtWayland::Output *>(outputResource->output_object);
-    if (!output)
-        return Q_NULLPTR;
+struct ::wl_resource *QWaylandOutput::outputForClient(QWaylandClient *client) const
+{
+    Q_D(const QWaylandOutput);
+    QWaylandOutputPrivate::Resource *r = d->resourceMap().value(client->client());
+    if (r)
+        return r->handle;
 
-    return output->waylandOutput();
+    return Q_NULLPTR;
 }
 
 void QWaylandOutput::setOutputSpace(QWaylandOutputSpace *outputSpace)
 {
     Q_ASSERT(outputSpace);
-    d_ptr->setOutputSpace(outputSpace, true);
+    Q_D(QWaylandOutput);
+    if (d->outputSpace == outputSpace)
+        return;
+
+    if (d->outputSpace) {
+        d->outputSpace->removeOutput(this);
+    }
+
+    d->outputSpace = outputSpace;
+
+    if (outputSpace) {
+        outputSpace->addOutput(this);
+    }
+
+    emit outputSpaceChanged();
 }
 
 QWaylandOutputSpace *QWaylandOutput::outputSpace() const
 {
-    return d_ptr->outputSpace();
+    return d_func()->outputSpace;
 }
 
 void QWaylandOutput::update()
@@ -102,66 +269,96 @@ void QWaylandOutput::update()
 
 QWaylandCompositor *QWaylandOutput::compositor() const
 {
-    return d_ptr->outputSpace()->compositor();
+    return d_func()->compositor;
 }
 
 QString QWaylandOutput::manufacturer() const
 {
-    return d_ptr->manufacturer();
+    return d_func()->manufacturer;
 }
 
 QString QWaylandOutput::model() const
 {
-    return d_ptr->model();
+    return d_func()->model;
 }
 
 QPoint QWaylandOutput::position() const
 {
-    return d_ptr->position();
+    return d_func()->position;
 }
 
 void QWaylandOutput::setPosition(const QPoint &pt)
 {
-    if (d_ptr->position() == pt)
+    Q_D(QWaylandOutput);
+    if (d->position == pt)
         return;
 
-    d_ptr->setPosition(pt);
+    d->position = pt;
+
+    d->sendGeometryInfo();
+
     Q_EMIT positionChanged();
     Q_EMIT geometryChanged();
 }
 
 QWaylandOutput::Mode QWaylandOutput::mode() const
 {
-    return d_ptr->mode();
+    return d_func()->mode;
 }
 
 void QWaylandOutput::setMode(const Mode &mode)
 {
-    if (d_ptr->mode().size == mode.size && d_ptr->mode().refreshRate == mode.refreshRate)
+    Q_D(QWaylandOutput);
+    if (d->mode.size == mode.size && d->mode.refreshRate == mode.refreshRate)
         return;
 
-    d_ptr->setMode(mode);
+    d->mode = mode;
+
+    Q_FOREACH (QWaylandOutputPrivate::Resource *resource, d->resourceMap().values()) {
+        d->send_mode(resource->handle, d->mode_current,
+                  d->mode.size.width(), d->mode.size.height(),
+                  d->mode.refreshRate * 1000);
+        if (resource->version() >= 2)
+            d->send_done(resource->handle);
+    }
+
     Q_EMIT modeChanged();
     Q_EMIT geometryChanged();
 
-    if (window()) {
-        window()->resize(mode.size);
-        window()->setMinimumSize(mode.size);
-        window()->setMaximumSize(mode.size);
+    if (d->window) {
+        d->window->resize(mode.size);
+        d->window->setMinimumSize(mode.size);
+        d->window->setMaximumSize(mode.size);
     }
 }
 
 QRect QWaylandOutput::geometry() const
 {
-    return d_ptr->geometry();
+    Q_D(const QWaylandOutput);
+    return QRect(d->position, d->mode.size);
 }
 
 void QWaylandOutput::setGeometry(const QRect &geometry)
 {
-    if (d_ptr->geometry() == geometry)
+    Q_D(QWaylandOutput);
+    if (d->position == geometry.topLeft() && d->mode.size == geometry.size())
         return;
 
-    d_ptr->setGeometry(geometry);
+    d->position = geometry.topLeft();
+    d->mode.size = geometry.size();
+
+    Q_FOREACH (QWaylandOutputPrivate::Resource *resource, d->resourceMap().values()) {
+        d->send_geometry(resource->handle,
+                      d->position.x(), d->position.y(),
+                      d->physicalSize.width(), d->physicalSize.height(),
+                      toWlSubpixel(d->subpixel), d->manufacturer, d->model,
+                      toWlTransform(d->transform));
+        d->send_mode(resource->handle, d->mode_current,
+                  d->mode.size.width(), d->mode.size.height(),
+                  d->mode.refreshRate * 1000);
+        if (resource->version() >= 2)
+            d->send_done(resource->handle);
+    }
     Q_EMIT positionChanged();
     Q_EMIT modeChanged();
 
@@ -174,126 +371,175 @@ void QWaylandOutput::setGeometry(const QRect &geometry)
 
 QRect QWaylandOutput::availableGeometry() const
 {
-    if (!d_ptr->availableGeometry().isValid())
-        return QRect(d_ptr->position(), d_ptr->mode().size);
+    Q_D(const QWaylandOutput);
+    if (!d->availableGeometry.isValid())
+        return QRect(d->position, d->mode.size);
 
-    return d_ptr->availableGeometry();
+    return d->availableGeometry;
 }
 
 void QWaylandOutput::setAvailableGeometry(const QRect &availableGeometry)
 {
-    if (d_ptr->availableGeometry() == availableGeometry)
+    Q_D(QWaylandOutput);
+    if (d->availableGeometry == availableGeometry)
         return;
 
-    d_ptr->setAvailableGeometry(availableGeometry);
+    d->availableGeometry = availableGeometry;
+
     Q_EMIT availableGeometryChanged();
 }
 
 QSize QWaylandOutput::physicalSize() const
 {
-    return d_ptr->physicalSize();
+    return d_func()->physicalSize;
 }
 
 void QWaylandOutput::setPhysicalSize(const QSize &size)
 {
-    if (d_ptr->physicalSize() == size)
+    Q_D(QWaylandOutput);
+    if (d->physicalSize == size)
         return;
 
-    d_ptr->setPhysicalSize(size);
+    d->physicalSize = size;
+
+    d->sendGeometryInfo();
+
     Q_EMIT physicalSizeChanged();
 }
 
 QWaylandOutput::Subpixel QWaylandOutput::subpixel() const
 {
-    return d_ptr->subpixel();
+    return d_func()->subpixel;
 }
 
 void QWaylandOutput::setSubpixel(const Subpixel &subpixel)
 {
-    if (d_ptr->subpixel() == subpixel)
+    Q_D(QWaylandOutput);
+    if (d->subpixel == subpixel)
         return;
 
-    d_ptr->setSubpixel(subpixel);
+    d->subpixel = subpixel;
+
+    d->sendGeometryInfo();
+
     Q_EMIT subpixelChanged();
 }
 
 QWaylandOutput::Transform QWaylandOutput::transform() const
 {
-    return d_ptr->transform();
+    return d_func()->transform;
 }
 
 void QWaylandOutput::setTransform(const Transform &transform)
 {
-    if (d_ptr->transform() == transform)
+    Q_D(QWaylandOutput);
+    if (d->transform == transform)
         return;
 
-    d_ptr->setTransform(transform);
+    d->transform = transform;
+
+    d->sendGeometryInfo();
+
     Q_EMIT transformChanged();
 }
 
 int QWaylandOutput::scaleFactor() const
 {
-    return d_ptr->scaleFactor();
+    return d_func()->scaleFactor;
 }
 
 void QWaylandOutput::setScaleFactor(int scale)
 {
-    if (d_ptr->scaleFactor() == scale)
+    Q_D(QWaylandOutput);
+    if (d->scaleFactor == scale)
         return;
 
-    d_ptr->setScaleFactor(scale);
-    Q_EMIT scaleFactorChanged();
+    d->scaleFactor = scale;
 
+    Q_FOREACH (QWaylandOutputPrivate::Resource *resource, d->resourceMap().values()) {
+        if (resource->version() >= 2) {
+            d->send_scale(resource->handle, scale);
+            d->send_done(resource->handle);
+        }
+    }
+
+    Q_EMIT scaleFactorChanged();
 }
 
 bool QWaylandOutput::sizeFollowsWindow() const
 {
-    return d_ptr->sizeFollowsWindow();
+    return d_func()->sizeFollowsWindow;
 }
 
 void QWaylandOutput::setSizeFollowsWindow(bool follow)
 {
-    d_ptr->setSizeFollowsWindow(follow);
+    Q_D(QWaylandOutput);
+    if (follow != d->sizeFollowsWindow) {
+        if (follow) {
+            QObject::connect(d->window, &QWindow::widthChanged, this, &QWaylandOutput::setWidth);
+            QObject::connect(d->window, &QWindow::heightChanged, this, &QWaylandOutput::setHeight);
+        } else {
+            QObject::disconnect(d->window, &QWindow::widthChanged, this, &QWaylandOutput::setWidth);
+            QObject::disconnect(d->window, &QWindow::heightChanged, this, &QWaylandOutput::setHeight);
+        }
+        d->sizeFollowsWindow = follow;
+        Q_EMIT sizeFollowsWindowChanged();
+    }
 }
 
 QWindow *QWaylandOutput::window() const
 {
-    return d_ptr->window();
+    return d_func()->window;
 }
 
 void QWaylandOutput::frameStarted()
 {
-    d_ptr->frameStarted();
+    Q_D(QWaylandOutput);
+    for (int i = 0; i < d->surfaceViews.size(); i++) {
+        QWaylandSurfaceViewMapper &surfacemapper = d->surfaceViews[i];
+        if (surfacemapper.maybeThrottelingView())
+            QWaylandSurfacePrivate::get(surfacemapper.surface)->frameStarted();
+    }
 }
 
 void QWaylandOutput::sendFrameCallbacks()
 {
-    d_ptr->sendFrameCallbacks();
+    Q_D(QWaylandOutput);
+    for (int i = 0; i < d->surfaceViews.size(); i++) {
+        const QWaylandSurfaceViewMapper &surfacemapper = d->surfaceViews.at(i);
+        if (surfacemapper.surface && surfacemapper.surface->isMapped()) {
+            if (!surfacemapper.has_entered) {
+                surfaceEnter(surfacemapper.surface);
+            }
+            if (surfacemapper.maybeThrottelingView())
+                QWaylandSurfacePrivate::get(surfacemapper.surface)->sendFrameCallback();
+        }
+    }
+    wl_display_flush_clients(d->compositor->display());
 }
 
 void QWaylandOutput::surfaceEnter(QWaylandSurface *surface)
 {
-    d_ptr->surfaceEnter(surface);
+    if (!surface)
+        return;
+    QWaylandSurfacePrivate::get(surface)->send_enter(outputForClient(surface->client()));
 }
 
 void QWaylandOutput::surfaceLeave(QWaylandSurface *surface)
 {
-    d_ptr->surfaceLeave(surface);
-}
-
-QtWayland::Output *QWaylandOutput::handle() const
-{
-    return d_ptr.data();
+    if (!surface)
+        return;
+    QWaylandSurfacePrivate::get(surface)->send_leave(outputForClient(surface->client()));
 }
 
 QWaylandView *QWaylandOutput::pickView(const QPointF &outputPosition) const
 {
-    const QVector<QtWayland::SurfaceViewMapper> surfaceViewMappers = d_ptr->surfaceMappers();
-    for (int nSurface = 0; surfaceViewMappers.size(); nSurface++) {
-        const QWaylandSurface *surface = surfaceViewMappers.at(nSurface).surface;
+    Q_D(const QWaylandOutput);
+    for (int nSurface = 0; d->surfaceViews.size(); nSurface++) {
+        const QWaylandSurface *surface = d->surfaceViews.at(nSurface).surface;
         if (surface->isCursorSurface())
             continue;
-        const QVector<QWaylandView *> views = surfaceViewMappers.at(nSurface).views;
+        const QVector<QWaylandView *> views = d->surfaceViews.at(nSurface).views;
         for (int nView = 0; views.size(); nView++) {
             if (QRectF(views.at(nView)->requestedPosition(), surface->size()).contains(outputPosition))
                 return views.at(nView);
@@ -309,17 +555,29 @@ QPointF QWaylandOutput::mapToView(QWaylandView *view, const QPointF &outputPosit
 
 void QWaylandOutput::setWidth(int newWidth)
 {
-    d_ptr->setWidth(newWidth);
+    Q_D(QWaylandOutput);
+    if (d->mode.size.width() == newWidth)
+        return;
+
+    QSize s = d->mode.size;
+    s.setWidth(newWidth);
+    setGeometry(QRect(d->position, s));
 }
 
 void QWaylandOutput::setHeight(int newHeight)
 {
-    d_ptr->setHeight(newHeight);
+    Q_D(QWaylandOutput);
+    if (d->mode.size.height() == newHeight)
+        return;
+
+    QSize s = d->mode.size;
+    s.setHeight(newHeight);
+    setGeometry(QRect(d->position, s));
 }
 
 QPointF QWaylandOutput::mapToOutputSpace(const QPointF &point)
 {
-    return point + d_ptr->topLeft();
+    return point + d_func()->position;
 }
 
 void QWaylandOutput::windowDestroyed()
diff --git a/src/compositor/compositor_api/qwaylandoutput.h b/src/compositor/compositor_api/qwaylandoutput.h
index f261f16a4..763bfa2ed 100644
--- a/src/compositor/compositor_api/qwaylandoutput.h
+++ b/src/compositor/compositor_api/qwaylandoutput.h
@@ -49,6 +49,7 @@ QT_BEGIN_NAMESPACE
 
 struct wl_resource;
 
+class QWaylandOutputPrivate;
 class QWaylandCompositor;
 class QWindow;
 class QWaylandSurface;
@@ -56,13 +57,10 @@ class QWaylandView;
 class QWaylandClient;
 class QWaylandOutputSpace;
 
-namespace QtWayland {
-    class Output;
-}
-
 class Q_COMPOSITOR_EXPORT QWaylandOutput : public QObject, public QWaylandExtensionContainer
 {
     Q_OBJECT
+    Q_DECLARE_PRIVATE(QWaylandOutput)
     Q_PROPERTY(QString manufacturer READ manufacturer CONSTANT)
     Q_PROPERTY(QString model READ model CONSTANT)
     Q_PROPERTY(QPoint position READ position WRITE setPosition NOTIFY positionChanged)
@@ -111,13 +109,14 @@ public:
     ~QWaylandOutput();
 
     static QWaylandOutput *fromResource(wl_resource *resource);
+    struct ::wl_resource *outputForClient(QWaylandClient *client) const;
+
+    QWaylandCompositor *compositor() const;
+    QWindow *window() const;
 
     void setOutputSpace(QWaylandOutputSpace *outputSpace);
     QWaylandOutputSpace *outputSpace() const;
 
-    virtual void update();
-
-    QWaylandCompositor *compositor() const;
 
     QString manufacturer() const;
 
@@ -149,8 +148,6 @@ public:
     int scaleFactor() const;
     void setScaleFactor(int scale);
 
-    QWindow *window() const;
-
     bool sizeFollowsWindow() const;
     void setSizeFollowsWindow(bool follow);
 
@@ -163,7 +160,7 @@ public:
     void surfaceEnter(QWaylandSurface *surface);
     void surfaceLeave(QWaylandSurface *surface);
 
-    QtWayland::Output *handle() const;
+    virtual void update();
 
     Q_INVOKABLE virtual QWaylandView *pickView(const QPointF &outputPosition) const;
     Q_INVOKABLE virtual QPointF mapToView(QWaylandView *view, const QPointF &surfacePosition) const;
@@ -183,9 +180,6 @@ Q_SIGNALS:
     void physicalSizeFollowsSizeChanged();
     void outputSpaceChanged();
 
-protected:
-    QScopedPointer<QtWayland::Output> d_ptr;
-
 private Q_SLOTS:
     void windowDestroyed();
 
diff --git a/src/compositor/compositor_api/qwaylandoutput_p.h b/src/compositor/compositor_api/qwaylandoutput_p.h
new file mode 100644
index 000000000..88d86d5f4
--- /dev/null
+++ b/src/compositor/compositor_api/qwaylandoutput_p.h
@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** Copyright (C) 2014-2015 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+** Copyright (C) 2013 Klarälvdalens Datakonsult AB (KDAB).
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWAYLANDOUTPUT_P_H
+#define QWAYLANDOUTPUT_P_H
+
+#include <QtCompositor/qwaylandexport.h>
+#include <QtCompositor/QWaylandOutput>
+#include <QtCompositor/QWaylandClient>
+#include <QtCompositor/QWaylandOutputSpace>
+#include <QtCompositor/QWaylandSurface>
+
+#include <QtCompositor/private/qwayland-server-wayland.h>
+
+#include <QtCore/QRect>
+#include <QtCore/QVector>
+
+#include <QtCore/private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QWaylandSurfaceViewMapper
+{
+    QWaylandSurfaceViewMapper()
+        : surface(0)
+        , views()
+        , has_entered(false)
+    {}
+
+    QWaylandSurfaceViewMapper(QWaylandSurface *s, QWaylandView *v)
+        : surface(s)
+        , views(1, v)
+        , has_entered(false)
+    {}
+
+    QWaylandView *maybeThrottelingView() const
+    {
+        for (int i = 0; i < views.size(); i++) {
+            if (surface && surface->throttlingView() == views.at(i))
+                return views.at(i);
+        }
+        return Q_NULLPTR;
+    }
+
+    QWaylandSurface *surface;
+    QVector<QWaylandView *> views;
+    bool has_entered;
+};
+
+class Q_COMPOSITOR_EXPORT QWaylandOutputPrivate : public QObjectPrivate, public QtWaylandServer::wl_output
+{
+public:
+    QWaylandOutputPrivate(QWaylandCompositor *compositor, QWindow *window, const QString &manufacturer, const QString &model);
+
+    ~QWaylandOutputPrivate();
+    static QWaylandOutputPrivate *get(QWaylandOutput *output) { return output->d_func(); }
+
+    void addView(QWaylandView *view);
+    void addView(QWaylandView *view, QWaylandSurface *surface);
+    void removeView(QWaylandView *view);
+    void removeView(QWaylandView *view, QWaylandSurface *surface);
+    void updateSurfaceForView(QWaylandView *view, QWaylandSurface *newSurface, QWaylandSurface *oldSurface);
+    void sendGeometryInfo();
+
+protected:
+    void output_bind_resource(Resource *resource) Q_DECL_OVERRIDE;
+
+
+private:
+    QWaylandCompositor *compositor;
+    QWaylandOutputSpace *outputSpace;
+    QWindow *window;
+    QString manufacturer;
+    QString model;
+    QPoint position;
+    QWaylandOutput::Mode mode;
+    QRect availableGeometry;
+    QVector<QWaylandSurfaceViewMapper> surfaceViews;
+    QSize physicalSize;
+    QWaylandOutput::Subpixel subpixel;
+    QWaylandOutput::Transform transform;
+    int scaleFactor;
+    bool sizeFollowsWindow;
+
+    Q_DECLARE_PUBLIC(QWaylandOutput)
+    Q_DISABLE_COPY(QWaylandOutputPrivate)
+};
+
+
+QT_END_NAMESPACE
+
+#endif  /*QWAYLANDOUTPUT_P_H*/
diff --git a/src/compositor/compositor_api/qwaylandoutputspace_p.h b/src/compositor/compositor_api/qwaylandoutputspace_p.h
index c10022ee9..127224bed 100644
--- a/src/compositor/compositor_api/qwaylandoutputspace_p.h
+++ b/src/compositor/compositor_api/qwaylandoutputspace_p.h
@@ -40,9 +40,11 @@
 #include <QtCore/private/qobject_p.h>
 
 #include "qwaylandoutputspace.h"
-#include "qwaylandcompositor.h"
-#include "wayland_wrapper/qwloutput_p.h"
+
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/QWaylandOutput>
 #include <QtCompositor/private/qwaylandcompositor_p.h>
+#include <QtCompositor/private/qwaylandoutput_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -95,17 +97,19 @@ public:
     {
         Q_Q(QWaylandOutputSpace);
         Q_ASSERT(output);
-        Q_ASSERT(!outputs.contains(output));
 
-        output->handle()->setOutputSpace(q, false);
+        if (outputs.contains(output))
+            return;
 
         if (primary)
             outputs.prepend(output);
         else
             outputs.append(output);
         adjustGeometry();
-        q->outputsChanged();
 
+        output->setOutputSpace(q);
+
+        q->outputsChanged();
     }
 
     static QWaylandOutputSpacePrivate *get(QWaylandOutputSpace *outputSpace) { return outputSpace->d_func(); }
diff --git a/src/compositor/compositor_api/qwaylandview.cpp b/src/compositor/compositor_api/qwaylandview.cpp
index 1dd570d94..c55bd5b5d 100644
--- a/src/compositor/compositor_api/qwaylandview.cpp
+++ b/src/compositor/compositor_api/qwaylandview.cpp
@@ -68,7 +68,7 @@ QWaylandView::~QWaylandView()
 {
     Q_D(QWaylandView);
     if (d->output)
-        d->output->handle()->removeView(this);
+        QWaylandOutputPrivate::get(d->output)->removeView(this);
     if (d->surface) {
         QWaylandInputDevice *i = d->surface->compositor()->defaultInputDevice();
         if (i->mouseFocus() == this)
@@ -230,7 +230,7 @@ void QWaylandView::waylandSurfaceChanged(QWaylandSurface *newSurface, QWaylandSu
 {
     Q_D(QWaylandView);
     if (d->output)
-        d->output->handle()->updateSurfaceForView(this, newSurface, oldSurface);
+        QWaylandOutputPrivate::get(d->output)->updateSurfaceForView(this, newSurface, oldSurface);
 }
 
 void QWaylandView::waylandSurfaceDestroyed()
@@ -240,10 +240,10 @@ void QWaylandView::waylandSurfaceDestroyed()
 void QWaylandView::waylandOutputChanged(QWaylandOutput *newOutput, QWaylandOutput *oldOutput)
 {
     if (oldOutput)
-        oldOutput->handle()->removeView(this);
+        QWaylandOutputPrivate::get(oldOutput)->removeView(this);
 
     if (newOutput)
-        newOutput->handle()->addView(this);
+        QWaylandOutputPrivate::get(newOutput)->addView(this);
 }
 
 QT_END_NAMESPACE