Fix various issues for previous commit

Change-Id: I4a4c9e46df0517e563cfa1d6930e636fab213bfc
Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>

10 files changed, 173 insertions, 220 deletions

diff --git a/src/datavisualization/engine/abstract3dcontroller.cpp b/src/datavisualization/engine/abstract3dcontroller.cpp
index 7392b714..9835dbe4 100644
--- a/src/datavisualization/engine/abstract3dcontroller.cpp
+++ b/src/datavisualization/engine/abstract3dcontroller.cpp
@@ -29,6 +29,7 @@
 #include "qtouch3dinputhandler.h"
 #include "qabstract3dseries_p.h"
 #include "thememanager_p.h"
+#include "q3dscene_p.h"
 
 #include <QThread>
 
@@ -53,7 +54,7 @@ Abstract3DController::Abstract3DController(QRect initialViewport, QObject *paren
     // Set initial theme
     setTheme(new Q3DTheme(Q3DTheme::ThemeQt));
 
-    m_scene->setViewport(initialViewport);
+    m_scene->d_ptr->setViewport(initialViewport);
 
     // Populate the scene
     m_scene->activeLight()->setPosition(defaultLightPos);
@@ -67,10 +68,8 @@ Abstract3DController::Abstract3DController(QRect initialViewport, QObject *paren
             &Abstract3DController::handleInputStateChanged);
     connect(inputHandler, &QAbstract3DInputHandler::positionChanged, this,
             &Abstract3DController::handleInputPositionChanged);
-    connect(m_scene, &Q3DScene::needRender, this,
+    connect(m_scene->d_ptr.data(), &Q3DScenePrivate::needRender, this,
             &Abstract3DController::emitNeedRender);
-    connect(m_scene, &Q3DScene::devicePixelRatioChanged, this,
-            &Abstract3DController::handlePixelRatioChanged);
 }
 
 Abstract3DController::~Abstract3DController()
@@ -357,13 +356,6 @@ void Abstract3DController::wheelEvent(QWheelEvent *event)
         m_activeInputHandler->wheelEvent(event);
 }
 
-void Abstract3DController::handlePixelRatioChanged(float ratio)
-{
-    Q_UNUSED(ratio);
-
-    emitNeedRender();
-}
-
 void Abstract3DController::handleThemeColorStyleChanged(Q3DTheme::ColorStyle style)
 {
     // Set value for series that have not explicitly set this value
diff --git a/src/datavisualization/engine/abstract3dcontroller_p.h b/src/datavisualization/engine/abstract3dcontroller_p.h
index 90a59b38..c56b8a72 100644
--- a/src/datavisualization/engine/abstract3dcontroller_p.h
+++ b/src/datavisualization/engine/abstract3dcontroller_p.h
@@ -34,7 +34,7 @@
 #include "drawer_p.h"
 #include "qabstract3dinputhandler.h"
 #include "qabstractdataproxy.h"
-#include "q3dscene.h"
+#include "q3dscene_p.h"
 #include "q3dbox.h"
 
 #include <QObject>
@@ -238,7 +238,6 @@ public slots:
     void handleInputStateChanged(QAbstract3DInputHandler::InputState state);
     void handleInputPositionChanged(const QPoint &position);
     void handleSeriesVisibilityChanged(bool visible);
-    void handlePixelRatioChanged(float ratio);
 
     void handleThemeColorStyleChanged(Q3DTheme::ColorStyle style);
     void handleThemeBaseColorsChanged(const QList<QColor> &color);
diff --git a/src/datavisualization/engine/abstract3drenderer.cpp b/src/datavisualization/engine/abstract3drenderer.cpp
index 89a7944d..ddff9fd3 100644
--- a/src/datavisualization/engine/abstract3drenderer.cpp
+++ b/src/datavisualization/engine/abstract3drenderer.cpp
@@ -171,12 +171,12 @@ void Abstract3DRenderer::updateScene(Q3DScene *scene)
     updateInputPosition(QPoint(logicalPixelPosition.x() * devicePixelRatio,
                                logicalPixelPosition.y() * devicePixelRatio));
 
-    m_viewport = m_cachedScene->glViewport();
-    m_secondarySubViewport = m_cachedScene->glSecondarySubViewport();
+    m_viewport = m_cachedScene->d_ptr->glViewport();
+    m_secondarySubViewport = m_cachedScene->d_ptr->glSecondarySubViewport();
 
-    if (m_primarySubViewport != m_cachedScene->glPrimarySubViewport()) {
+    if (m_primarySubViewport != m_cachedScene->d_ptr->glPrimarySubViewport()) {
         // Resize of primary subviewport means resizing shadow and selection buffers
-        m_primarySubViewport = m_cachedScene->glPrimarySubViewport();
+        m_primarySubViewport = m_cachedScene->d_ptr->glPrimarySubViewport();
         handleResize();
     }
 
diff --git a/src/datavisualization/engine/abstract3drenderer_p.h b/src/datavisualization/engine/abstract3drenderer_p.h
index f9e97299..d888798e 100644
--- a/src/datavisualization/engine/abstract3drenderer_p.h
+++ b/src/datavisualization/engine/abstract3drenderer_p.h
@@ -123,17 +123,6 @@ protected:
 
     QDataVis::SelectionFlags m_cachedSelectionMode;
 
-    Q3DTheme::ColorStyle m_cachedColorStyle;
-    QColor m_cachedObjectColor;
-    QLinearGradient m_cachedObjectGradient;
-    GLuint m_objectGradientTexture;
-    QColor m_cachedSingleHighlightColor;
-    QLinearGradient m_cachedSingleHighlightGradient;
-    GLuint m_singleHighlightGradientTexture;
-    QColor m_cachedMultiHighlightColor;
-    QLinearGradient m_cachedMultiHighlightGradient;
-    GLuint m_multiHighlightGradientTexture;
-
     AxisRenderCache m_axisCacheX;
     AxisRenderCache m_axisCacheY;
     AxisRenderCache m_axisCacheZ;
diff --git a/src/datavisualization/engine/q3dscene.cpp b/src/datavisualization/engine/q3dscene.cpp
index b3a4cc55..d8104b3a 100644
--- a/src/datavisualization/engine/q3dscene.cpp
+++ b/src/datavisualization/engine/q3dscene.cpp
@@ -160,84 +160,6 @@ QRect Q3DScene::viewport() const
     return d_ptr->m_viewport;
 }
 
-void Q3DScene::setViewport(const QRect &viewport)
-{
-    if (d_ptr->m_viewport != viewport) {
-        d_ptr->m_viewport = viewport;
-        calculateSubViewports();
-        emit needRender();
-    }
-}
-
-/*!
- * Sets the \a width and \a height of the viewport only, without changing its location.
- */
-void Q3DScene::setViewportSize(int width, int height)
-{
-    if (d_ptr->m_viewport.width() != width
-            || d_ptr->m_viewport.height() != height) {
-        d_ptr->m_viewport.setWidth(width);
-        d_ptr->m_viewport.setHeight(height);
-        calculateSubViewports();
-        emit needRender();
-    }
-}
-
-/*!
- * \internal
- */
-void Q3DScene::calculateSubViewports()
-{
-    // Calculates the default subviewport layout
-    const float smallerViewPortRatio = 0.2;
-    if (d_ptr->m_isSlicingActive) {
-        setPrimarySubViewport(QRect(0,
-                                    0,
-                                    d_ptr->m_viewport.width() * smallerViewPortRatio,
-                                    d_ptr->m_viewport.height() * smallerViewPortRatio));
-        setSecondarySubViewport(QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height()));
-    } else {
-        setPrimarySubViewport(QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height()));
-        setSecondarySubViewport(QRect(0, 0, 0, 0));
-    }
-
-    updateGLViewport();
-}
-
-/*!
- * \internal
- */
-void Q3DScene::updateGLViewport()
-{
-    // Update GL viewport
-    d_ptr->m_glViewport.setX(d_ptr->m_viewport.x() * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glViewport.setY((d_ptr->m_windowSize.height() - (d_ptr->m_viewport.y() + d_ptr->m_viewport.height())) * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glViewport.setWidth(d_ptr->m_viewport.width() * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glViewport.setHeight(d_ptr->m_viewport.height() * d_ptr->m_devicePixelRatio);
-
-    d_ptr->m_changeTracker.viewportChanged = true;
-
-    // Do default subviewport changes first, then allow signal listeners to override.
-    updateGLSubViewports();
-    emit viewportChanged(d_ptr->m_viewport);
-}
-
-/*!
- * \internal
- */
-void Q3DScene::updateGLSubViewports()
-{
-    d_ptr->m_glPrimarySubViewport.setX((d_ptr->m_primarySubViewport.x() + d_ptr->m_viewport.x()) * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glPrimarySubViewport.setY((d_ptr->m_windowSize.height() - (d_ptr->m_primarySubViewport.y() + d_ptr->m_viewport.y() + d_ptr->m_primarySubViewport.height())) * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glPrimarySubViewport.setWidth(d_ptr->m_primarySubViewport.width() * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glPrimarySubViewport.setHeight(d_ptr->m_primarySubViewport.height() * d_ptr->m_devicePixelRatio);
-
-    d_ptr->m_glSecondarySubViewport.setX(d_ptr->m_secondarySubViewport.x() * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glSecondarySubViewport.setY((d_ptr->m_windowSize.height() - (d_ptr->m_secondarySubViewport.y() + d_ptr->m_viewport.y() + d_ptr->m_secondarySubViewport.height())) * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glSecondarySubViewport.setWidth(d_ptr->m_secondarySubViewport.width() * d_ptr->m_devicePixelRatio);
-    d_ptr->m_glSecondarySubViewport.setHeight(d_ptr->m_secondarySubViewport.height() * d_ptr->m_devicePixelRatio);
-}
-
 /*!
  * \property Q3DScene::primarySubViewport
  *
@@ -251,13 +173,14 @@ QRect Q3DScene::primarySubViewport() const
 
 void Q3DScene::setPrimarySubViewport(const QRect &primarySubViewport)
 {
-    if (d_ptr->m_primarySubViewport != primarySubViewport) {
-        QRect clipRect = QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height());
-        d_ptr->m_primarySubViewport = primarySubViewport.intersected(clipRect);
-        updateGLSubViewports();
+    QRect clipRect = QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height());
+    QRect intersectedViewport = primarySubViewport.intersected(clipRect);
+    if (d_ptr->m_primarySubViewport != intersectedViewport) {
+        d_ptr->m_primarySubViewport = intersectedViewport;
+        d_ptr->updateGLSubViewports();
         d_ptr->m_changeTracker.primarySubViewportChanged = true;
-        emit primarySubViewportChanged(primarySubViewport);
-        emit needRender();
+        emit primarySubViewportChanged(intersectedViewport);
+        emit d_ptr->needRender();
     }
 }
 
@@ -312,13 +235,14 @@ QRect Q3DScene::secondarySubViewport() const
 
 void Q3DScene::setSecondarySubViewport(const QRect &secondarySubViewport)
 {
-    if (d_ptr->m_secondarySubViewport != secondarySubViewport) {
-        QRect clipRect = QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height());
-        d_ptr->m_secondarySubViewport = secondarySubViewport.intersected(clipRect);
-        updateGLSubViewports();
+    QRect clipRect = QRect(0, 0, d_ptr->m_viewport.width(), d_ptr->m_viewport.height());
+    QRect intersectedViewport = secondarySubViewport.intersected(clipRect);
+    if (d_ptr->m_secondarySubViewport != intersectedViewport) {
+        d_ptr->m_secondarySubViewport = intersectedViewport;
+        d_ptr->updateGLSubViewports();
         d_ptr->m_changeTracker.secondarySubViewportChanged = true;
-        emit secondarySubViewportChanged(secondarySubViewport);
-        emit needRender();
+        emit secondarySubViewportChanged(intersectedViewport);
+        emit d_ptr->needRender();
     }
 }
 
@@ -336,7 +260,7 @@ void Q3DScene::setSelectionQueryPosition(const QPoint &point)
         d_ptr->m_selectionQueryPosition = point;
         d_ptr->m_changeTracker.selectionQueryPositionChanged = true;
         emit selectionQueryPositionChanged(point);
-        emit needRender();
+        emit d_ptr->needRender();
     }
 }
 
@@ -370,9 +294,9 @@ void Q3DScene::setSlicingActive(bool isSlicing)
     if (d_ptr->m_isSlicingActive != isSlicing) {
         d_ptr->m_isSlicingActive = isSlicing;
         d_ptr->m_changeTracker.slicingActivatedChanged = true;
-        calculateSubViewports();
+        d_ptr->calculateSubViewports();
         emit slicingActiveChanged(isSlicing);
-        emit needRender();
+        emit d_ptr->needRender();
     }
 }
 
@@ -393,7 +317,7 @@ void Q3DScene::setSecondarySubviewOnTop(bool isSecondaryOnTop)
         d_ptr->m_isSecondarySubviewOnTop = isSecondaryOnTop;
         d_ptr->m_changeTracker.subViewportOrderChanged = true;
         emit secondarySubviewOnTopChanged(isSecondaryOnTop);
-        emit needRender();
+        emit d_ptr->needRender();
     }
 }
 
@@ -419,28 +343,28 @@ void Q3DScene::setActiveCamera(Q3DCamera *camera)
 
     if (camera != d_ptr->m_camera) {
         if (d_ptr->m_camera) {
-            disconnect(d_ptr->m_camera, &Q3DCamera::xRotationChanged, this,
-                       &Q3DScene::needRender);
-            disconnect(d_ptr->m_camera, &Q3DCamera::yRotationChanged, this,
-                       &Q3DScene::needRender);
-            disconnect(d_ptr->m_camera, &Q3DCamera::zoomLevelChanged, this,
-                       &Q3DScene::needRender);
+            disconnect(d_ptr->m_camera, &Q3DCamera::xRotationChanged, d_ptr.data(),
+                       &Q3DScenePrivate::needRender);
+            disconnect(d_ptr->m_camera, &Q3DCamera::yRotationChanged, d_ptr.data(),
+                       &Q3DScenePrivate::needRender);
+            disconnect(d_ptr->m_camera, &Q3DCamera::zoomLevelChanged, d_ptr.data(),
+                       &Q3DScenePrivate::needRender);
         }
 
         d_ptr->m_camera = camera;
         d_ptr->m_changeTracker.cameraChanged = true;
 
         if (camera) {
-            connect(camera, &Q3DCamera::xRotationChanged, this,
-                    &Q3DScene::needRender);
-            connect(camera, &Q3DCamera::yRotationChanged, this,
-                    &Q3DScene::needRender);
-            connect(camera, &Q3DCamera::zoomLevelChanged, this,
-                    &Q3DScene::needRender);
+            connect(camera, &Q3DCamera::xRotationChanged, d_ptr.data(),
+                    &Q3DScenePrivate::needRender);
+            connect(camera, &Q3DCamera::yRotationChanged, d_ptr.data(),
+                    &Q3DScenePrivate::needRender);
+            connect(camera, &Q3DCamera::zoomLevelChanged, d_ptr.data(),
+                    &Q3DScenePrivate::needRender);
         }
 
         emit activeCameraChanged(camera);
-        emit needRender();
+        emit d_ptr->needRender();
     }
 }
 
@@ -488,7 +412,8 @@ void Q3DScene::setDevicePixelRatio(float pixelRatio)
         d_ptr->m_devicePixelRatio = pixelRatio;
         d_ptr->m_changeTracker.devicePixelRatioChanged = true;
         emit devicePixelRatioChanged(pixelRatio);
-        updateGLViewport();
+        d_ptr->updateGLViewport();
+        emit d_ptr->needRender();
     }
 }
 
@@ -509,61 +434,8 @@ void Q3DScene::setLightPositionRelativeToCamera(const QVector3D &relativePositio
                                                                    distanceModifier));
 }
 
-/*!
- * \internal
- * Sets the size of the window being rendered to. With widget based graphs, this
- * is equal to the size of the QWindow and is same as the bounding rectangle.
- * With declarative graphs this is equal to the size of the QQuickWindow and
- * can be different from the bounding rectangle.
- */
-void Q3DScene::setWindowSize(const QSize &size)
-{
-    if (d_ptr->m_windowSize != size) {
-        d_ptr->m_windowSize = size;
-        updateGLViewport();
-        d_ptr->m_changeTracker.windowSizeChanged = true;
-        emit windowSizeChanged(size);
-        emit needRender();
-    }
-}
-
-/*!
- * \internal
- */
-QSize Q3DScene::windowSize() const
-{
-    return d_ptr->m_windowSize;
-}
-
-/*!
- * \internal
- */
-QRect Q3DScene::glViewport()
-{
-    return d_ptr->m_glViewport;
-}
-
-/*!
- * \internal
- */
-QRect Q3DScene::glPrimarySubViewport()
-{
-    return d_ptr->m_glPrimarySubViewport;
-}
-
-/*!
- * \internal
- */
-QRect Q3DScene::glSecondarySubViewport()
-{
-    return d_ptr->m_glSecondarySubViewport;
-}
-
-/*!
- * \fn Q3DScene::needRender()
- * \internal
- */
 Q3DScenePrivate::Q3DScenePrivate(Q3DScene *q) :
+    QObject(0),
     q_ptr(q),
     m_isSecondarySubviewOnTop(true),
     m_devicePixelRatio(1.f),
@@ -586,12 +458,12 @@ Q3DScenePrivate::~Q3DScenePrivate()
 void Q3DScenePrivate::sync(Q3DScenePrivate &other)
 {
     if (m_changeTracker.windowSizeChanged) {
-        other.q_ptr->setWindowSize(q_ptr->windowSize());
+        other.setWindowSize(windowSize());
         m_changeTracker.windowSizeChanged = false;
         other.m_changeTracker.windowSizeChanged = false;
     }
     if (m_changeTracker.viewportChanged) {
-        other.q_ptr->setViewport(q_ptr->viewport());
+        other.setViewport(m_viewport);
         m_changeTracker.viewportChanged = false;
         other.m_changeTracker.viewportChanged = false;
     }
@@ -642,4 +514,107 @@ void Q3DScenePrivate::sync(Q3DScenePrivate &other)
     }
 }
 
+void Q3DScenePrivate::setViewport(const QRect &viewport)
+{
+    if (m_viewport != viewport) {
+        m_viewport = viewport;
+        calculateSubViewports();
+        emit needRender();
+    }
+}
+
+void Q3DScenePrivate::setViewportSize(int width, int height)
+{
+    if (m_viewport.width() != width
+            || m_viewport.height() != height) {
+        m_viewport.setWidth(width);
+        m_viewport.setHeight(height);
+        calculateSubViewports();
+        emit needRender();
+    }
+}
+
+/*!
+ * \internal
+ * Sets the size of the window being rendered to. With widget based graphs, this
+ * is equal to the size of the QWindow and is same as the bounding rectangle.
+ * With declarative graphs this is equal to the size of the QQuickWindow and
+ * can be different from the bounding rectangle.
+ */
+void Q3DScenePrivate::setWindowSize(const QSize &size)
+{
+    if (m_windowSize != size) {
+        m_windowSize = size;
+        updateGLViewport();
+        m_changeTracker.windowSizeChanged = true;
+        emit needRender();
+    }
+}
+
+QSize Q3DScenePrivate::windowSize() const
+{
+    return m_windowSize;
+}
+
+void Q3DScenePrivate::calculateSubViewports()
+{
+    // Calculates the default subviewport layout
+    const float smallerViewPortRatio = 0.2f;
+    if (m_isSlicingActive) {
+        q_ptr->setPrimarySubViewport(QRect(0,
+                                    0,
+                                    m_viewport.width() * smallerViewPortRatio,
+                                    m_viewport.height() * smallerViewPortRatio));
+        q_ptr->setSecondarySubViewport(QRect(0, 0, m_viewport.width(), m_viewport.height()));
+    } else {
+        q_ptr->setPrimarySubViewport(QRect(0, 0, m_viewport.width(), m_viewport.height()));
+        q_ptr->setSecondarySubViewport(QRect(0, 0, 0, 0));
+    }
+
+    updateGLViewport();
+}
+
+void Q3DScenePrivate::updateGLViewport()
+{
+    // Update GL viewport
+    m_glViewport.setX(m_viewport.x() * m_devicePixelRatio);
+    m_glViewport.setY((m_windowSize.height() - (m_viewport.y() + m_viewport.height())) * m_devicePixelRatio);
+    m_glViewport.setWidth(m_viewport.width() * m_devicePixelRatio);
+    m_glViewport.setHeight(m_viewport.height() * m_devicePixelRatio);
+
+    m_changeTracker.viewportChanged = true;
+
+    // Do default subviewport changes first, then allow signal listeners to override.
+    updateGLSubViewports();
+    emit q_ptr->viewportChanged(m_viewport);
+}
+
+void Q3DScenePrivate::updateGLSubViewports()
+{
+    m_glPrimarySubViewport.setX((m_primarySubViewport.x() + m_viewport.x()) * m_devicePixelRatio);
+    m_glPrimarySubViewport.setY((m_windowSize.height() - (m_primarySubViewport.y() + m_viewport.y() + m_primarySubViewport.height())) * m_devicePixelRatio);
+    m_glPrimarySubViewport.setWidth(m_primarySubViewport.width() * m_devicePixelRatio);
+    m_glPrimarySubViewport.setHeight(m_primarySubViewport.height() * m_devicePixelRatio);
+
+    m_glSecondarySubViewport.setX(m_secondarySubViewport.x() * m_devicePixelRatio);
+    m_glSecondarySubViewport.setY((m_windowSize.height() - (m_secondarySubViewport.y() + m_viewport.y() + m_secondarySubViewport.height())) * m_devicePixelRatio);
+    m_glSecondarySubViewport.setWidth(m_secondarySubViewport.width() * m_devicePixelRatio);
+    m_glSecondarySubViewport.setHeight(m_secondarySubViewport.height() * m_devicePixelRatio);
+}
+
+QRect Q3DScenePrivate::glViewport()
+{
+    return m_glViewport;
+}
+
+QRect Q3DScenePrivate::glPrimarySubViewport()
+{
+    return m_glPrimarySubViewport;
+}
+
+QRect Q3DScenePrivate::glSecondarySubViewport()
+{
+    return m_glSecondarySubViewport;
+}
+
 QT_DATAVISUALIZATION_END_NAMESPACE
diff --git a/src/datavisualization/engine/q3dscene.h b/src/datavisualization/engine/q3dscene.h
index 5231edb2..b0dadff9 100644
--- a/src/datavisualization/engine/q3dscene.h
+++ b/src/datavisualization/engine/q3dscene.h
@@ -88,27 +88,9 @@ signals:
     void activeCameraChanged(const Q3DCamera *camera);
     void activeLightChanged(const Q3DLight *light);
     void devicePixelRatioChanged(float pixelRatio);
-    void needRender();
     void selectionQueryPositionChanged(const QPoint position);
 
 private:
-signals:
-    void windowSizeChanged(const QSize size);
-
-private:
-    void setViewport(const QRect &viewport);
-    void setViewportSize(int width, int height);
-    void setWindowSize(const QSize &size);
-    QSize windowSize() const;
-    void calculateSubViewports();
-    void updateGLViewport();
-    void updateGLSubViewports();
-
-
-    QRect glViewport();
-    QRect glPrimarySubViewport();
-    QRect glSecondarySubViewport();
-
     QScopedPointer<Q3DScenePrivate> d_ptr;
 
     Q_DISABLE_COPY(Q3DScene)
diff --git a/src/datavisualization/engine/q3dscene_p.h b/src/datavisualization/engine/q3dscene_p.h
index 1c6ba5ab..c9d9d1f6 100644
--- a/src/datavisualization/engine/q3dscene_p.h
+++ b/src/datavisualization/engine/q3dscene_p.h
@@ -65,14 +65,31 @@ struct Q3DSceneChangeBitField {
     }
 };
 
-class Q3DScenePrivate
+class QT_DATAVISUALIZATION_EXPORT Q3DScenePrivate : public QObject
 {
+    Q_OBJECT
 public:
     Q3DScenePrivate(Q3DScene *q);
     ~Q3DScenePrivate();
 
     void sync(Q3DScenePrivate &other);
 
+    void setViewport(const QRect &viewport);
+    void setViewportSize(int width, int height);
+    void setWindowSize(const QSize &size);
+    QSize windowSize() const;
+    void calculateSubViewports();
+    void updateGLViewport();
+    void updateGLSubViewports();
+
+    QRect glViewport();
+    QRect glPrimarySubViewport();
+    QRect glSecondarySubViewport();
+
+signals:
+    void needRender();
+
+public:
     Q3DScene *q_ptr;
     Q3DSceneChangeBitField m_changeTracker;
 
diff --git a/src/datavisualization/engine/q3dwindow.cpp b/src/datavisualization/engine/q3dwindow.cpp
index 4a31900f..379a2f5a 100644
--- a/src/datavisualization/engine/q3dwindow.cpp
+++ b/src/datavisualization/engine/q3dwindow.cpp
@@ -20,13 +20,13 @@
 #include "q3dwindow_p.h"
 #include "abstract3dcontroller_p.h"
 #include "qabstract3dinputhandler_p.h"
-#include <QGuiApplication>
+#include "q3dscene_p.h"
 
+#include <QGuiApplication>
 #include <QOpenGLContext>
 #include <QOpenGLPaintDevice>
 #include <QPainter>
 
-#include <QDebug>
 
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
 
@@ -176,8 +176,8 @@ void Q3DWindow::resizeEvent(QResizeEvent *event)
     Q_UNUSED(event);
 
     Q3DScene *scene = d_ptr->m_visualController->scene();
-    scene->setWindowSize(QSize(width(), height()));
-    scene->setViewport(QRect(x(),y(),width(),height()));
+    scene->d_ptr->setWindowSize(QSize(width(), height()));
+    scene->d_ptr->setViewport(QRect(x(), y(), width(), height()));
 }
 
 /*!
diff --git a/src/datavisualization/engine/selectionpointer_p.h b/src/datavisualization/engine/selectionpointer_p.h
index e4f6c699..8faeb9ac 100644
--- a/src/datavisualization/engine/selectionpointer_p.h
+++ b/src/datavisualization/engine/selectionpointer_p.h
@@ -51,7 +51,7 @@ class Theme;
 class Drawer;
 class Q3DCamera;
 
-class QT_DATAVISUALIZATION_EXPORT SelectionPointer : public QObject, protected QOpenGLFunctions
+class SelectionPointer : public QObject, protected QOpenGLFunctions
 {
     Q_OBJECT
 
diff --git a/src/datavisualizationqml2/abstractdeclarative.cpp b/src/datavisualizationqml2/abstractdeclarative.cpp
index 0d6d7526..148612cd 100644
--- a/src/datavisualizationqml2/abstractdeclarative.cpp
+++ b/src/datavisualizationqml2/abstractdeclarative.cpp
@@ -134,14 +134,13 @@ void AbstractDeclarative::updateWindowParameters()
         if (win->devicePixelRatio() != scene->devicePixelRatio())
             scene->setDevicePixelRatio(win->devicePixelRatio());
 
-        if (win->size() != scene->windowSize())
-            scene->setWindowSize(QSize(win->width(), win->height()));
+        if (win->size() != scene->d_ptr->windowSize())
+            scene->d_ptr->setWindowSize(QSize(win->width(), win->height()));
 
         QPointF point = QQuickItem::mapToScene(QPointF(m_cachedGeometry.x(), m_cachedGeometry.y()));
         if (m_controller) {
-            scene->setViewport(QRect(point.x(), point.y(), m_cachedGeometry.width(), m_cachedGeometry.height()));
+            scene->d_ptr->setViewport(QRect(point.x(), point.y(), m_cachedGeometry.width(), m_cachedGeometry.height()));
         }
-
     }
 }