1 files changed, 207 insertions, 120 deletions

diff --git a/src/datavisualization/engine/abstract3dcontroller.cpp b/src/datavisualization/engine/abstract3dcontroller.cpp
index 9835dbe4..4989ddb5 100644
--- a/src/datavisualization/engine/abstract3dcontroller.cpp
+++ b/src/datavisualization/engine/abstract3dcontroller.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2013 Digia Plc
+** Copyright (C) 2014 Digia Plc
 ** All rights reserved.
 ** For any questions to Digia, please use contact form at http://qt.digia.com
 **
@@ -18,9 +18,9 @@
 
 #include "abstract3dcontroller_p.h"
 #include "camerahelper_p.h"
-#include "q3dabstractaxis_p.h"
-#include "q3dvalueaxis.h"
-#include "q3dcategoryaxis.h"
+#include "qabstract3daxis_p.h"
+#include "qvalue3daxis.h"
+#include "qcategory3daxis.h"
 #include "abstract3drenderer_p.h"
 #include "q3dcamera.h"
 #include "q3dlight.h"
@@ -29,18 +29,21 @@
 #include "qtouch3dinputhandler.h"
 #include "qabstract3dseries_p.h"
 #include "thememanager_p.h"
+#include "q3dtheme_p.h"
 #include "q3dscene_p.h"
+#include "q3dscene.h"
 
 #include <QThread>
 
-QT_DATAVISUALIZATION_BEGIN_NAMESPACE
+QT_BEGIN_NAMESPACE_DATAVISUALIZATION
 
-Abstract3DController::Abstract3DController(QRect initialViewport, QObject *parent) :
+Abstract3DController::Abstract3DController(QRect initialViewport, Q3DScene *scene,
+                                           QObject *parent) :
     QObject(parent),
     m_themeManager(new ThemeManager(this)),
-    m_selectionMode(QDataVis::SelectionItem),
-    m_shadowQuality(QDataVis::ShadowQualityMedium),
-    m_scene(new Q3DScene()),
+    m_selectionMode(QAbstract3DGraph::SelectionItem),
+    m_shadowQuality(QAbstract3DGraph::ShadowQualityMedium),
+    m_scene(scene),
     m_activeInputHandler(0),
     m_axisX(0),
     m_axisY(0),
@@ -51,8 +54,13 @@ Abstract3DController::Abstract3DController(QRect initialViewport, QObject *paren
     m_isSeriesVisualsDirty(true),
     m_renderPending(false)
 {
+    if (!m_scene)
+        m_scene = new Q3DScene;
+
     // Set initial theme
-    setTheme(new Q3DTheme(Q3DTheme::ThemeQt));
+    Q3DTheme *defaultTheme = new Q3DTheme(Q3DTheme::ThemeQt);
+    defaultTheme->d_ptr->setDefaultTheme(true);
+    setActiveTheme(defaultTheme);
 
     m_scene->d_ptr->setViewport(initialViewport);
 
@@ -64,8 +72,8 @@ Abstract3DController::Abstract3DController(QRect initialViewport, QObject *paren
     inputHandler = new QTouch3DInputHandler();
     inputHandler->d_ptr->m_isDefaultHandler = true;
     setActiveInputHandler(inputHandler);
-    connect(inputHandler, &QAbstract3DInputHandler::inputStateChanged, this,
-            &Abstract3DController::handleInputStateChanged);
+    connect(inputHandler, &QAbstract3DInputHandler::inputViewChanged, this,
+            &Abstract3DController::handleInputViewChanged);
     connect(inputHandler, &QAbstract3DInputHandler::positionChanged, this,
             &Abstract3DController::handleInputPositionChanged);
     connect(m_scene->d_ptr.data(), &Q3DScenePrivate::needRender, this,
@@ -94,15 +102,30 @@ void Abstract3DController::setRenderer(Abstract3DRenderer *renderer)
 
 void Abstract3DController::addSeries(QAbstract3DSeries *series)
 {
-    if (series && !m_seriesList.contains(series)) {
-        int oldSize = m_seriesList.size();
-        m_seriesList.append(series);
-        series->d_ptr->setController(this);
-        QObject::connect(series, &QAbstract3DSeries::visibilityChanged,
-                         this, &Abstract3DController::handleSeriesVisibilityChanged);
+    insertSeries(m_seriesList.size(), series);
+}
+
+void Abstract3DController::insertSeries(int index, QAbstract3DSeries *series)
+{
+    if (series) {
+        if (m_seriesList.contains(series)) {
+            int oldIndex = m_seriesList.indexOf(series);
+            if (index != oldIndex) {
+                m_seriesList.removeOne(series);
+                if (oldIndex < index)
+                    index--;
+                m_seriesList.insert(index, series);
+            }
+        } else {
+            int oldSize = m_seriesList.size();
+            m_seriesList.insert(index, series);
+            series->d_ptr->setController(this);
+            QObject::connect(series, &QAbstract3DSeries::visibilityChanged,
+                             this, &Abstract3DController::handleSeriesVisibilityChanged);
+            series->d_ptr->resetToTheme(*m_themeManager->activeTheme(), oldSize, false);
+        }
         if (series->isVisible())
             handleSeriesVisibilityChangedBySender(series);
-        series->d_ptr->resetToTheme(*m_themeManager->theme(), oldSize, false);
     }
 }
 
@@ -129,13 +152,20 @@ QList<QAbstract3DSeries *> Abstract3DController::seriesList()
  */
 void Abstract3DController::synchDataToRenderer()
 {
-    // If we don't have a renderer, don't do anything
-    if (!m_renderer)
-        return;
+    // Subclass implementations check for renderer validity already, so no need to check here.
+
+    // If there is a pending click from renderer, handle that first.
+    if (m_renderer->isClickPending()) {
+        handlePendingClick();
+        m_renderer->clearClickPending();
+    }
+
+    startRecordingRemovesAndInserts();
 
-    m_renderer->updateScene(m_scene);
+    if (m_scene->d_ptr->m_sceneDirty)
+        m_renderer->updateScene(m_scene);
 
-    m_renderer->updateTheme(m_themeManager->theme());
+    m_renderer->updateTheme(m_themeManager->activeTheme());
 
     if (m_changeTracker.shadowQualityChanged) {
         m_renderer->updateShadowQuality(m_shadowQuality);
@@ -148,144 +178,144 @@ void Abstract3DController::synchDataToRenderer()
     }
 
     if (m_changeTracker.axisXTypeChanged) {
-        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationX, m_axisX->type());
+        m_renderer->updateAxisType(QAbstract3DAxis::AxisOrientationX, m_axisX->type());
         m_changeTracker.axisXTypeChanged = false;
     }
 
     if (m_changeTracker.axisYTypeChanged) {
-        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationY, m_axisY->type());
+        m_renderer->updateAxisType(QAbstract3DAxis::AxisOrientationY, m_axisY->type());
         m_changeTracker.axisYTypeChanged = false;
     }
 
     if (m_changeTracker.axisZTypeChanged) {
-        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->type());
+        m_renderer->updateAxisType(QAbstract3DAxis::AxisOrientationZ, m_axisZ->type());
         m_changeTracker.axisZTypeChanged = false;
     }
 
     if (m_changeTracker.axisXTitleChanged) {
-        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationX, m_axisX->title());
+        m_renderer->updateAxisTitle(QAbstract3DAxis::AxisOrientationX, m_axisX->title());
         m_changeTracker.axisXTitleChanged = false;
     }
 
     if (m_changeTracker.axisYTitleChanged) {
-        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationY, m_axisY->title());
+        m_renderer->updateAxisTitle(QAbstract3DAxis::AxisOrientationY, m_axisY->title());
         m_changeTracker.axisYTitleChanged = false;
     }
 
     if (m_changeTracker.axisZTitleChanged) {
-        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->title());
+        m_renderer->updateAxisTitle(QAbstract3DAxis::AxisOrientationZ, m_axisZ->title());
         m_changeTracker.axisZTitleChanged = false;
     }
 
     if (m_changeTracker.axisXLabelsChanged) {
-        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationX, m_axisX->labels());
+        m_renderer->updateAxisLabels(QAbstract3DAxis::AxisOrientationX, m_axisX->labels());
         m_changeTracker.axisXLabelsChanged = false;
     }
 
     if (m_changeTracker.axisYLabelsChanged) {
-        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationY, m_axisY->labels());
+        m_renderer->updateAxisLabels(QAbstract3DAxis::AxisOrientationY, m_axisY->labels());
         m_changeTracker.axisYLabelsChanged = false;
     }
     if (m_changeTracker.axisZLabelsChanged) {
-        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->labels());
+        m_renderer->updateAxisLabels(QAbstract3DAxis::AxisOrientationZ, m_axisZ->labels());
         m_changeTracker.axisZLabelsChanged = false;
     }
 
     if (m_changeTracker.axisXRangeChanged) {
-        m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationX, m_axisX->min(),
+        m_renderer->updateAxisRange(QAbstract3DAxis::AxisOrientationX, m_axisX->min(),
                                     m_axisX->max());
         m_changeTracker.axisXRangeChanged = false;
     }
 
     if (m_changeTracker.axisYRangeChanged) {
-        m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationY, m_axisY->min(),
+        m_renderer->updateAxisRange(QAbstract3DAxis::AxisOrientationY, m_axisY->min(),
                                     m_axisY->max());
         m_changeTracker.axisYRangeChanged = false;
     }
 
     if (m_changeTracker.axisZRangeChanged) {
-        m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->min(),
+        m_renderer->updateAxisRange(QAbstract3DAxis::AxisOrientationZ, m_axisZ->min(),
                                     m_axisZ->max());
         m_changeTracker.axisZRangeChanged = false;
     }
 
     if (m_changeTracker.axisXSegmentCountChanged) {
         m_changeTracker.axisXSegmentCountChanged = false;
-        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
-            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisX = static_cast<QValue3DAxis *>(m_axisX);
+            m_renderer->updateAxisSegmentCount(QAbstract3DAxis::AxisOrientationX,
                                                valueAxisX->segmentCount());
         }
     }
 
     if (m_changeTracker.axisYSegmentCountChanged) {
         m_changeTracker.axisYSegmentCountChanged = false;
-        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
-            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisY = static_cast<QValue3DAxis *>(m_axisY);
+            m_renderer->updateAxisSegmentCount(QAbstract3DAxis::AxisOrientationY,
                                                valueAxisY->segmentCount());
         }
     }
 
     if (m_changeTracker.axisZSegmentCountChanged) {
         m_changeTracker.axisZSegmentCountChanged = false;
-        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
-            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisZ = static_cast<QValue3DAxis *>(m_axisZ);
+            m_renderer->updateAxisSegmentCount(QAbstract3DAxis::AxisOrientationZ,
                                                valueAxisZ->segmentCount());
         }
     }
 
     if (m_changeTracker.axisXSubSegmentCountChanged) {
         m_changeTracker.axisXSubSegmentCountChanged = false;
-        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
-            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisX = static_cast<QValue3DAxis *>(m_axisX);
+            m_renderer->updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientationX,
                                                   valueAxisX->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisYSubSegmentCountChanged) {
         m_changeTracker.axisYSubSegmentCountChanged = false;
-        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
-            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisY = static_cast<QValue3DAxis *>(m_axisY);
+            m_renderer->updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientationY,
                                                   valueAxisY->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisZSubSegmentCountChanged) {
         m_changeTracker.axisZSubSegmentCountChanged = false;
-        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
-            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisZ = static_cast<QValue3DAxis *>(m_axisZ);
+            m_renderer->updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientationZ,
                                                   valueAxisZ->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisXLabelFormatChanged) {
         m_changeTracker.axisXLabelFormatChanged = false;
-        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
-            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisX = static_cast<QValue3DAxis *>(m_axisX);
+            m_renderer->updateAxisLabelFormat(QAbstract3DAxis::AxisOrientationX,
                                               valueAxisX->labelFormat());
         }
     }
 
     if (m_changeTracker.axisYLabelFormatChanged) {
         m_changeTracker.axisYLabelFormatChanged = false;
-        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
-            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisY = static_cast<QValue3DAxis *>(m_axisY);
+            m_renderer->updateAxisLabelFormat(QAbstract3DAxis::AxisOrientationY,
                                               valueAxisY->labelFormat());
         }
     }
 
     if (m_changeTracker.axisZLabelFormatChanged) {
         m_changeTracker.axisZLabelFormatChanged = false;
-        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
-            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
-            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & QAbstract3DAxis::AxisTypeValue) {
+            QValue3DAxis *valueAxisZ = static_cast<QValue3DAxis *>(m_axisZ);
+            m_renderer->updateAxisLabelFormat(QAbstract3DAxis::AxisOrientationZ,
                                               valueAxisZ->labelFormat());
         }
     }
@@ -446,37 +476,62 @@ void Abstract3DController::handleThemeMultiHighlightGradientChanged(const QLinea
     markSeriesVisualsDirty();
 }
 
-void Abstract3DController::setAxisX(Q3DAbstractAxis *axis)
+void Abstract3DController::handleThemeTypeChanged(Q3DTheme::Theme theme)
 {
-    setAxisHelper(Q3DAbstractAxis::AxisOrientationX, axis, &m_axisX);
+    Q_UNUSED(theme)
+
+    // Changing theme type is logically equivalent of changing the entire theme
+    // object, so reset all attached series to the new theme.
+
+    Q3DTheme *activeTheme = m_themeManager->activeTheme();
+    for (int i = 0; i < m_seriesList.size(); i++)
+        m_seriesList.at(i)->d_ptr->resetToTheme(*activeTheme, i, true);
+    markSeriesVisualsDirty();
+}
+
+void Abstract3DController::setAxisX(QAbstract3DAxis *axis)
+{
+    // Setting null axis will always create new default axis
+    if (!axis || axis != m_axisX) {
+        setAxisHelper(QAbstract3DAxis::AxisOrientationX, axis, &m_axisX);
+        emit axisXChanged(m_axisX);
+    }
 }
 
-Q3DAbstractAxis *Abstract3DController::axisX()
+QAbstract3DAxis *Abstract3DController::axisX()
 {
     return m_axisX;
 }
 
-void Abstract3DController::setAxisY(Q3DAbstractAxis *axis)
+void Abstract3DController::setAxisY(QAbstract3DAxis *axis)
 {
-    setAxisHelper(Q3DAbstractAxis::AxisOrientationY, axis, &m_axisY);
+    // Setting null axis will always create new default axis
+    if (!axis || axis != m_axisY) {
+        setAxisHelper(QAbstract3DAxis::AxisOrientationY, axis, &m_axisY);
+        emit axisYChanged(m_axisY);
+    }
 }
 
-Q3DAbstractAxis *Abstract3DController::axisY()
+QAbstract3DAxis *Abstract3DController::axisY()
 {
     return m_axisY;
 }
 
-void Abstract3DController::setAxisZ(Q3DAbstractAxis *axis)
+void Abstract3DController::setAxisZ(QAbstract3DAxis *axis)
 {
-    setAxisHelper(Q3DAbstractAxis::AxisOrientationZ, axis, &m_axisZ);
+    // Setting null axis will always create new default axis
+    if (!axis || axis != m_axisZ) {
+        setAxisHelper(QAbstract3DAxis::AxisOrientationZ, axis, &m_axisZ);
+        emit axisZChanged(m_axisZ);
+    }
 }
 
-Q3DAbstractAxis *Abstract3DController::axisZ()
+QAbstract3DAxis *Abstract3DController::axisZ()
 {
     return m_axisZ;
 }
 
-void Abstract3DController::addAxis(Q3DAbstractAxis *axis)
+void Abstract3DController::addAxis(QAbstract3DAxis *axis)
 {
     Q_ASSERT(axis);
     Abstract3DController *owner = qobject_cast<Abstract3DController *>(axis->parent());
@@ -488,7 +543,7 @@ void Abstract3DController::addAxis(Q3DAbstractAxis *axis)
         m_axes.append(axis);
 }
 
-void Abstract3DController::releaseAxis(Q3DAbstractAxis *axis)
+void Abstract3DController::releaseAxis(QAbstract3DAxis *axis)
 {
     if (axis && m_axes.contains(axis)) {
         // Clear the default status from released default axes
@@ -497,13 +552,13 @@ void Abstract3DController::releaseAxis(Q3DAbstractAxis *axis)
 
         // If the axis is in use, replace it with a temporary one
         switch (axis->orientation()) {
-        case Q3DAbstractAxis::AxisOrientationX:
+        case QAbstract3DAxis::AxisOrientationX:
             setAxisX(0);
             break;
-        case Q3DAbstractAxis::AxisOrientationY:
+        case QAbstract3DAxis::AxisOrientationY:
             setAxisY(0);
             break;
-        case Q3DAbstractAxis::AxisOrientationZ:
+        case QAbstract3DAxis::AxisOrientationZ:
             setAxisZ(0);
             break;
         default:
@@ -515,7 +570,7 @@ void Abstract3DController::releaseAxis(Q3DAbstractAxis *axis)
     }
 }
 
-QList<Q3DAbstractAxis *> Abstract3DController::axes() const
+QList<QAbstract3DAxis *> Abstract3DController::axes() const
 {
     return m_axes;
 }
@@ -525,7 +580,8 @@ void Abstract3DController::addInputHandler(QAbstract3DInputHandler *inputHandler
     Q_ASSERT(inputHandler);
     Abstract3DController *owner = qobject_cast<Abstract3DController *>(inputHandler->parent());
     if (owner != this) {
-        Q_ASSERT_X(!owner, "addInputHandler", "Input handler already attached to another component.");
+        Q_ASSERT_X(!owner, "addInputHandler",
+                   "Input handler already attached to another component.");
         inputHandler->setParent(this);
     }
 
@@ -582,6 +638,11 @@ QAbstract3DInputHandler* Abstract3DController::activeInputHandler()
     return m_activeInputHandler;
 }
 
+QList<QAbstract3DInputHandler *> Abstract3DController::inputHandlers() const
+{
+    return m_inputHandlers;
+}
+
 int Abstract3DController::zoomLevel()
 {
     return m_scene->activeCamera()->zoomLevel();
@@ -595,25 +656,46 @@ void Abstract3DController::setZoomLevel(int zoomLevel)
     emitNeedRender();
 }
 
-void Abstract3DController::setTheme(Q3DTheme *theme)
+void Abstract3DController::addTheme(Q3DTheme *theme)
+{
+    m_themeManager->addTheme(theme);
+}
+
+void Abstract3DController::releaseTheme(Q3DTheme *theme)
+{
+    Q3DTheme *oldTheme = m_themeManager->activeTheme();
+
+    m_themeManager->releaseTheme(theme);
+
+    if (oldTheme != m_themeManager->activeTheme())
+        emit activeThemeChanged(m_themeManager->activeTheme());
+}
+QList<Q3DTheme *> Abstract3DController::themes() const
+{
+    return m_themeManager->themes();
+}
+
+void Abstract3DController::setActiveTheme(Q3DTheme *theme)
 {
-    if (theme != m_themeManager->theme()) {
-        m_themeManager->setTheme(theme);
+    if (theme != m_themeManager->activeTheme()) {
+        m_themeManager->setActiveTheme(theme);
         m_changeTracker.themeChanged = true;
+        // Default theme can be created by theme manager, so ensure we have correct theme
+        Q3DTheme *newActiveTheme = m_themeManager->activeTheme();
         // Reset all attached series to the new theme
         for (int i = 0; i < m_seriesList.size(); i++)
-            m_seriesList.at(i)->d_ptr->resetToTheme(*theme, i, true);
+            m_seriesList.at(i)->d_ptr->resetToTheme(*newActiveTheme, i, true);
         markSeriesVisualsDirty();
-        emit themeChanged(theme);
+        emit activeThemeChanged(newActiveTheme);
     }
 }
 
-Q3DTheme *Abstract3DController::theme() const
+Q3DTheme *Abstract3DController::activeTheme() const
 {
-    return m_themeManager->theme();
+    return m_themeManager->activeTheme();
 }
 
-void Abstract3DController::setSelectionMode(QDataVis::SelectionFlags mode)
+void Abstract3DController::setSelectionMode(QAbstract3DGraph::SelectionFlags mode)
 {
     if (mode != m_selectionMode) {
         m_selectionMode = mode;
@@ -623,12 +705,12 @@ void Abstract3DController::setSelectionMode(QDataVis::SelectionFlags mode)
     }
 }
 
-QDataVis::SelectionFlags Abstract3DController::selectionMode() const
+QAbstract3DGraph::SelectionFlags Abstract3DController::selectionMode() const
 {
     return m_selectionMode;
 }
 
-void Abstract3DController::setShadowQuality(QDataVis::ShadowQuality quality)
+void Abstract3DController::setShadowQuality(QAbstract3DGraph::ShadowQuality quality)
 {
     if (quality != m_shadowQuality) {
         m_shadowQuality = quality;
@@ -638,7 +720,7 @@ void Abstract3DController::setShadowQuality(QDataVis::ShadowQuality quality)
     }
 }
 
-QDataVis::ShadowQuality Abstract3DController::shadowQuality() const
+QAbstract3DGraph::ShadowQuality Abstract3DController::shadowQuality() const
 {
     return m_shadowQuality;
 }
@@ -776,7 +858,7 @@ void Abstract3DController::handleAxisAutoAdjustRangeChanged(bool autoAdjust)
     if (sender != m_axisX && sender != m_axisY && sender != m_axisZ)
         return;
 
-    Q3DAbstractAxis *axis = static_cast<Q3DAbstractAxis*>(sender);
+    QAbstract3DAxis *axis = static_cast<QAbstract3DAxis*>(sender);
     handleAxisAutoAdjustRangeChangedInOrientation(axis->orientation(), autoAdjust);
 }
 
@@ -786,15 +868,15 @@ void Abstract3DController::handleAxisLabelFormatChanged(const QString &format)
     handleAxisLabelFormatChangedBySender(sender());
 }
 
-void Abstract3DController::handleInputStateChanged(QAbstract3DInputHandler::InputState state)
+void Abstract3DController::handleInputViewChanged(QAbstract3DInputHandler::InputView view)
 {
-    // When in automatic slicing mode, input state change to overview disables slice mode
-    if (m_selectionMode.testFlag(QDataVis::SelectionSlice)
-            && state == QAbstract3DInputHandler::InputStateOnPrimaryView) {
+    // When in automatic slicing mode, input view change to primary disables slice mode
+    if (m_selectionMode.testFlag(QAbstract3DGraph::SelectionSlice)
+            && view == QAbstract3DInputHandler::InputViewOnPrimary) {
         setSlicingActive(false);
     }
 
-    m_changeTracker.inputStateChanged = true;
+    m_changeTracker.inputViewChanged = true;
     emitNeedRender();
 }
 
@@ -813,7 +895,7 @@ void Abstract3DController::handleSeriesVisibilityChanged(bool visible)
     handleSeriesVisibilityChangedBySender(sender());
 }
 
-void Abstract3DController::handleRequestShadowQuality(QDataVis::ShadowQuality quality)
+void Abstract3DController::handleRequestShadowQuality(QAbstract3DGraph::ShadowQuality quality)
 {
     setShadowQuality(quality);
 }
@@ -845,15 +927,15 @@ void Abstract3DController::handleSeriesVisibilityChangedBySender(QObject *sender
     emitNeedRender();
 }
 
-void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orientation,
-                                         Q3DAbstractAxis *axis, Q3DAbstractAxis **axisPtr)
+void Abstract3DController::setAxisHelper(QAbstract3DAxis::AxisOrientation orientation,
+                                         QAbstract3DAxis *axis, QAbstract3DAxis **axisPtr)
 {
     // Setting null axis indicates using default axis
     if (!axis)
         axis = createDefaultAxis(orientation);
 
     // If old axis is default axis, delete it
-    Q3DAbstractAxis *oldAxis = *axisPtr;
+    QAbstract3DAxis *oldAxis = *axisPtr;
     if (oldAxis) {
         if (oldAxis->d_ptr->isDefaultAxis()) {
             m_axes.removeAll(oldAxis);
@@ -862,7 +944,7 @@ void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orient
         } else {
             // Disconnect the old axis from use
             QObject::disconnect(oldAxis, 0, this, 0);
-            oldAxis->d_ptr->setOrientation(Q3DAbstractAxis::AxisOrientationNone);
+            oldAxis->d_ptr->setOrientation(QAbstract3DAxis::AxisOrientationNone);
         }
     }
 
@@ -874,20 +956,20 @@ void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orient
 
     axis->d_ptr->setOrientation(orientation);
 
-    QObject::connect(axis, &Q3DAbstractAxis::titleChanged,
+    QObject::connect(axis, &QAbstract3DAxis::titleChanged,
                      this, &Abstract3DController::handleAxisTitleChanged);
-    QObject::connect(axis, &Q3DAbstractAxis::labelsChanged,
+    QObject::connect(axis, &QAbstract3DAxis::labelsChanged,
                      this, &Abstract3DController::handleAxisLabelsChanged);
-    QObject::connect(axis, &Q3DAbstractAxis::rangeChanged,
+    QObject::connect(axis, &QAbstract3DAxis::rangeChanged,
                      this, &Abstract3DController::handleAxisRangeChanged);
-    QObject::connect(axis, &Q3DAbstractAxis::autoAdjustRangeChanged,
+    QObject::connect(axis, &QAbstract3DAxis::autoAdjustRangeChanged,
                      this, &Abstract3DController::handleAxisAutoAdjustRangeChanged);
 
-    if (orientation == Q3DAbstractAxis::AxisOrientationX)
+    if (orientation == QAbstract3DAxis::AxisOrientationX)
         m_changeTracker.axisXTypeChanged = true;
-    else if (orientation == Q3DAbstractAxis::AxisOrientationY)
+    else if (orientation == QAbstract3DAxis::AxisOrientationY)
         m_changeTracker.axisYTypeChanged = true;
-    else if (orientation == Q3DAbstractAxis::AxisOrientationZ)
+    else if (orientation == QAbstract3DAxis::AxisOrientationZ)
         m_changeTracker.axisZTypeChanged = true;
 
     handleAxisTitleChangedBySender(axis);
@@ -896,13 +978,13 @@ void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orient
     handleAxisAutoAdjustRangeChangedInOrientation(axis->orientation(),
                                                   axis->isAutoAdjustRange());
 
-    if (axis->type() & Q3DAbstractAxis::AxisTypeValue) {
-        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(axis);
-        QObject::connect(valueAxis, &Q3DValueAxis::segmentCountChanged,
+    if (axis->type() & QAbstract3DAxis::AxisTypeValue) {
+        QValue3DAxis *valueAxis = static_cast<QValue3DAxis *>(axis);
+        QObject::connect(valueAxis, &QValue3DAxis::segmentCountChanged,
                          this, &Abstract3DController::handleAxisSegmentCountChanged);
-        QObject::connect(valueAxis, &Q3DValueAxis::subSegmentCountChanged,
+        QObject::connect(valueAxis, &QValue3DAxis::subSegmentCountChanged,
                          this, &Abstract3DController::handleAxisSubSegmentCountChanged);
-        QObject::connect(valueAxis, &Q3DValueAxis::labelFormatChanged,
+        QObject::connect(valueAxis, &QValue3DAxis::labelFormatChanged,
                          this, &Abstract3DController::handleAxisLabelFormatChanged);
 
         handleAxisSegmentCountChangedBySender(valueAxis);
@@ -911,33 +993,38 @@ void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orient
     }
 }
 
-Q3DAbstractAxis *Abstract3DController::createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation)
+QAbstract3DAxis *Abstract3DController::createDefaultAxis(QAbstract3DAxis::AxisOrientation orientation)
 {
     Q_UNUSED(orientation)
 
     // The default default axis is a value axis. If the graph type has a different default axis
     // for some orientation, this function needs to be overridden.
-    Q3DAbstractAxis *defaultAxis = createDefaultValueAxis();
+    QAbstract3DAxis *defaultAxis = createDefaultValueAxis();
     return defaultAxis;
 }
 
-Q3DValueAxis *Abstract3DController::createDefaultValueAxis()
+QValue3DAxis *Abstract3DController::createDefaultValueAxis()
 {
     // Default value axis has single segment, empty label format, and auto scaling
-    Q3DValueAxis *defaultAxis = new Q3DValueAxis;
+    QValue3DAxis *defaultAxis = new QValue3DAxis;
     defaultAxis->d_ptr->setDefaultAxis(true);
 
     return defaultAxis;
 }
 
-Q3DCategoryAxis *Abstract3DController::createDefaultCategoryAxis()
+QCategory3DAxis *Abstract3DController::createDefaultCategoryAxis()
 {
     // Default category axis has no labels
-    Q3DCategoryAxis *defaultAxis = new Q3DCategoryAxis;
+    QCategory3DAxis *defaultAxis = new QCategory3DAxis;
     defaultAxis->d_ptr->setDefaultAxis(true);
     return defaultAxis;
 }
 
+void Abstract3DController::startRecordingRemovesAndInserts()
+{
+    // Default implementation does nothing
+}
+
 void Abstract3DController::emitNeedRender()
 {
     if (!m_renderPending) {
@@ -946,4 +1033,4 @@ void Abstract3DController::emitNeedRender()
     }
 }
 
-QT_DATAVISUALIZATION_END_NAMESPACE
+QT_END_NAMESPACE_DATAVISUALIZATION