Rename axis classes

Moved the '3D' in axis class names so that the classes would be
in line with other '3D' classes.

Task-number: QTRD-2674
Change-Id: Ie4f8a10babe3bf1b0b30b366863f55ed02ec66ba
Reviewed-by: Mika Salmela <mika.salmela@digia.com>

22 files changed, 249 insertions, 249 deletions

diff --git a/src/datavisualization/engine/abstract3dcontroller.cpp b/src/datavisualization/engine/abstract3dcontroller.cpp
index fb732139..09c75ceb 100644
--- a/src/datavisualization/engine/abstract3dcontroller.cpp
+++ b/src/datavisualization/engine/abstract3dcontroller.cpp
@@ -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"
@@ -148,144 +148,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());
         }
     }
@@ -459,37 +459,37 @@ void Abstract3DController::handleThemeTypeChanged(Q3DTheme::Theme theme)
     markSeriesVisualsDirty();
 }
 
-void Abstract3DController::setAxisX(Q3DAbstractAxis *axis)
+void Abstract3DController::setAxisX(QAbstract3DAxis *axis)
 {
-    setAxisHelper(Q3DAbstractAxis::AxisOrientationX, axis, &m_axisX);
+    setAxisHelper(QAbstract3DAxis::AxisOrientationX, axis, &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);
+    setAxisHelper(QAbstract3DAxis::AxisOrientationY, axis, &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);
+    setAxisHelper(QAbstract3DAxis::AxisOrientationZ, axis, &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());
@@ -501,7 +501,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
@@ -510,13 +510,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:
@@ -528,7 +528,7 @@ void Abstract3DController::releaseAxis(Q3DAbstractAxis *axis)
     }
 }
 
-QList<Q3DAbstractAxis *> Abstract3DController::axes() const
+QList<QAbstract3DAxis *> Abstract3DController::axes() const
 {
     return m_axes;
 }
@@ -810,7 +810,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);
 }
 
@@ -879,15 +879,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);
@@ -896,7 +896,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);
         }
     }
 
@@ -908,20 +908,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);
@@ -930,13 +930,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);
@@ -945,29 +945,29 @@ 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;
 }
diff --git a/src/datavisualization/engine/abstract3dcontroller_p.h b/src/datavisualization/engine/abstract3dcontroller_p.h
index b9c99210..91083eb9 100644
--- a/src/datavisualization/engine/abstract3dcontroller_p.h
+++ b/src/datavisualization/engine/abstract3dcontroller_p.h
@@ -30,7 +30,7 @@
 #define ABSTRACT3DCONTROLLER_P_H
 
 #include "datavisualizationglobal_p.h"
-#include "q3dabstractaxis.h"
+#include "qabstract3daxis.h"
 #include "drawer_p.h"
 #include "qabstract3dinputhandler.h"
 #include "qabstractdataproxy.h"
@@ -145,11 +145,11 @@ protected:
     QAbstract3DInputHandler *m_activeInputHandler;
     CameraHelper *m_cameraHelper;
     // Active axes
-    Q3DAbstractAxis *m_axisX;
-    Q3DAbstractAxis *m_axisY;
-    Q3DAbstractAxis *m_axisZ;
+    QAbstract3DAxis *m_axisX;
+    QAbstract3DAxis *m_axisY;
+    QAbstract3DAxis *m_axisZ;
 
-    QList<Q3DAbstractAxis *> m_axes; // List of all added axes
+    QList<QAbstract3DAxis *> m_axes; // List of all added axes
     Abstract3DRenderer *m_renderer;
     bool m_isDataDirty;
     bool m_isSeriesVisibilityDirty;
@@ -173,15 +173,15 @@ public:
     virtual void removeSeries(QAbstract3DSeries *series);
     QList<QAbstract3DSeries *> seriesList();
 
-    virtual void setAxisX(Q3DAbstractAxis *axis);
-    virtual Q3DAbstractAxis *axisX();
-    virtual void setAxisY(Q3DAbstractAxis *axis);
-    virtual Q3DAbstractAxis *axisY();
-    virtual void setAxisZ(Q3DAbstractAxis *axis);
-    virtual Q3DAbstractAxis *axisZ();
-    virtual void addAxis(Q3DAbstractAxis *axis);
-    virtual void releaseAxis(Q3DAbstractAxis *axis);
-    virtual QList<Q3DAbstractAxis *> axes() const; // Omits default axes
+    virtual void setAxisX(QAbstract3DAxis *axis);
+    virtual QAbstract3DAxis *axisX();
+    virtual void setAxisY(QAbstract3DAxis *axis);
+    virtual QAbstract3DAxis *axisY();
+    virtual void setAxisZ(QAbstract3DAxis *axis);
+    virtual QAbstract3DAxis *axisZ();
+    virtual void addAxis(QAbstract3DAxis *axis);
+    virtual void releaseAxis(QAbstract3DAxis *axis);
+    virtual QList<QAbstract3DAxis *> axes() const; // Omits default axes
 
     virtual void addInputHandler(QAbstract3DInputHandler *inputHandler);
     virtual void releaseInputHandler(QAbstract3DInputHandler *inputHandler);
@@ -226,7 +226,7 @@ public:
     virtual void handleAxisSegmentCountChangedBySender(QObject *sender);
     virtual void handleAxisSubSegmentCountChangedBySender(QObject *sender);
     virtual void handleAxisAutoAdjustRangeChangedInOrientation(
-            Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust) = 0;
+            QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust) = 0;
     virtual void handleAxisLabelFormatChangedBySender(QObject *sender);
     virtual void handleSeriesVisibilityChangedBySender(QObject *sender);
 
@@ -262,13 +262,13 @@ signals:
     void needRender();
 
 protected:
-    virtual Q3DAbstractAxis *createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation);
-    Q3DValueAxis *createDefaultValueAxis();
-    Q3DCategoryAxis *createDefaultCategoryAxis();
+    virtual QAbstract3DAxis *createDefaultAxis(QAbstract3DAxis::AxisOrientation orientation);
+    QValue3DAxis *createDefaultValueAxis();
+    QCategory3DAxis *createDefaultCategoryAxis();
 
 private:
-    void setAxisHelper(Q3DAbstractAxis::AxisOrientation orientation, Q3DAbstractAxis *axis,
-                       Q3DAbstractAxis **axisPtr);
+    void setAxisHelper(QAbstract3DAxis::AxisOrientation orientation, QAbstract3DAxis *axis,
+                       QAbstract3DAxis **axisPtr);
 
     friend class Bars3DController;
 };
diff --git a/src/datavisualization/engine/abstract3drenderer.cpp b/src/datavisualization/engine/abstract3drenderer.cpp
index 74088b7c..32435946 100644
--- a/src/datavisualization/engine/abstract3drenderer.cpp
+++ b/src/datavisualization/engine/abstract3drenderer.cpp
@@ -17,7 +17,7 @@
 ****************************************************************************/
 
 #include "abstract3drenderer_p.h"
-#include "q3dvalueaxis.h"
+#include "qvalue3daxis.h"
 #include "texturehelper_p.h"
 #include "utils_p.h"
 #include "q3dscene_p.h"
@@ -85,9 +85,9 @@ void Abstract3DRenderer::initializeOpenGL()
     m_textureHelper = new TextureHelper();
     m_drawer->initializeOpenGL();
 
-    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationX).setDrawer(m_drawer);
-    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationY).setDrawer(m_drawer);
-    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationZ).setDrawer(m_drawer);
+    axisCacheForOrientation(QAbstract3DAxis::AxisOrientationX).setDrawer(m_drawer);
+    axisCacheForOrientation(QAbstract3DAxis::AxisOrientationY).setDrawer(m_drawer);
+    axisCacheForOrientation(QAbstract3DAxis::AxisOrientationZ).setDrawer(m_drawer);
 }
 
 void Abstract3DRenderer::render(const GLuint defaultFboHandle)
@@ -280,39 +280,39 @@ void Abstract3DRenderer::handleResize()
 #endif
 }
 
-void Abstract3DRenderer::updateAxisType(Q3DAbstractAxis::AxisOrientation orientation, Q3DAbstractAxis::AxisType type)
+void Abstract3DRenderer::updateAxisType(QAbstract3DAxis::AxisOrientation orientation, QAbstract3DAxis::AxisType type)
 {
     axisCacheForOrientation(orientation).setType(type);
 }
 
-void Abstract3DRenderer::updateAxisTitle(Q3DAbstractAxis::AxisOrientation orientation, const QString &title)
+void Abstract3DRenderer::updateAxisTitle(QAbstract3DAxis::AxisOrientation orientation, const QString &title)
 {
     axisCacheForOrientation(orientation).setTitle(title);
 }
 
-void Abstract3DRenderer::updateAxisLabels(Q3DAbstractAxis::AxisOrientation orientation, const QStringList &labels)
+void Abstract3DRenderer::updateAxisLabels(QAbstract3DAxis::AxisOrientation orientation, const QStringList &labels)
 {
     axisCacheForOrientation(orientation).setLabels(labels);
 }
 
-void Abstract3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, float min, float max)
+void Abstract3DRenderer::updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min, float max)
 {
     AxisRenderCache &cache = axisCacheForOrientation(orientation);
     cache.setMin(min);
     cache.setMax(max);
 }
 
-void Abstract3DRenderer::updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count)
+void Abstract3DRenderer::updateAxisSegmentCount(QAbstract3DAxis::AxisOrientation orientation, int count)
 {
     axisCacheForOrientation(orientation).setSegmentCount(count);
 }
 
-void Abstract3DRenderer::updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count)
+void Abstract3DRenderer::updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientation orientation, int count)
 {
     axisCacheForOrientation(orientation).setSubSegmentCount(count);
 }
 
-void Abstract3DRenderer::updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientation orientation, const QString &format)
+void Abstract3DRenderer::updateAxisLabelFormat(QAbstract3DAxis::AxisOrientation orientation, const QString &format)
 {
     axisCacheForOrientation(orientation).setLabelFormat(format);
 }
@@ -353,14 +353,14 @@ void Abstract3DRenderer::updateSeries(const QList<QAbstract3DSeries *> &seriesLi
     }
 }
 
-AxisRenderCache &Abstract3DRenderer::axisCacheForOrientation(Q3DAbstractAxis::AxisOrientation orientation)
+AxisRenderCache &Abstract3DRenderer::axisCacheForOrientation(QAbstract3DAxis::AxisOrientation orientation)
 {
     switch (orientation) {
-    case Q3DAbstractAxis::AxisOrientationX:
+    case QAbstract3DAxis::AxisOrientationX:
         return m_axisCacheX;
-    case Q3DAbstractAxis::AxisOrientationY:
+    case QAbstract3DAxis::AxisOrientationY:
         return m_axisCacheY;
-    case Q3DAbstractAxis::AxisOrientationZ:
+    case QAbstract3DAxis::AxisOrientationZ:
         return m_axisCacheZ;
     default:
         qFatal("Abstract3DRenderer::axisCacheForOrientation");
diff --git a/src/datavisualization/engine/abstract3drenderer_p.h b/src/datavisualization/engine/abstract3drenderer_p.h
index 17a55ac9..068ee0ef 100644
--- a/src/datavisualization/engine/abstract3drenderer_p.h
+++ b/src/datavisualization/engine/abstract3drenderer_p.h
@@ -84,13 +84,13 @@ public:
     virtual void initShaders(const QString &vertexShader, const QString &fragmentShader) = 0;
     virtual void initGradientShaders(const QString &vertexShader, const QString &fragmentShader);
     virtual void initBackgroundShaders(const QString &vertexShader, const QString &fragmentShader) = 0;
-    virtual void updateAxisType(Q3DAbstractAxis::AxisOrientation orientation, Q3DAbstractAxis::AxisType type);
-    virtual void updateAxisTitle(Q3DAbstractAxis::AxisOrientation orientation, const QString &title);
-    virtual void updateAxisLabels(Q3DAbstractAxis::AxisOrientation orientation, const QStringList &labels);
-    virtual void updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, float min, float max);
-    virtual void updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count);
-    virtual void updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count);
-    virtual void updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientation orientation, const QString &format);
+    virtual void updateAxisType(QAbstract3DAxis::AxisOrientation orientation, QAbstract3DAxis::AxisType type);
+    virtual void updateAxisTitle(QAbstract3DAxis::AxisOrientation orientation, const QString &title);
+    virtual void updateAxisLabels(QAbstract3DAxis::AxisOrientation orientation, const QStringList &labels);
+    virtual void updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min, float max);
+    virtual void updateAxisSegmentCount(QAbstract3DAxis::AxisOrientation orientation, int count);
+    virtual void updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientation orientation, int count);
+    virtual void updateAxisLabelFormat(QAbstract3DAxis::AxisOrientation orientation, const QString &format);
 
     virtual void fixMeshFileName(QString &fileName, QAbstract3DSeries::Mesh mesh);
     void fixGradientAndGenerateTexture(QLinearGradient *gradient, GLuint *gradientTexture);
@@ -108,7 +108,7 @@ protected:
     virtual void handleShadowQualityChange();
     virtual void handleResize();
 
-    AxisRenderCache &axisCacheForOrientation(Q3DAbstractAxis::AxisOrientation orientation);
+    AxisRenderCache &axisCacheForOrientation(QAbstract3DAxis::AxisOrientation orientation);
 
     virtual void lowerShadowQuality();
 
diff --git a/src/datavisualization/engine/axisrendercache.cpp b/src/datavisualization/engine/axisrendercache.cpp
index f7960b2b..5ada62ca 100644
--- a/src/datavisualization/engine/axisrendercache.cpp
+++ b/src/datavisualization/engine/axisrendercache.cpp
@@ -23,7 +23,7 @@
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
 
 AxisRenderCache::AxisRenderCache()
-    : m_type(Q3DAbstractAxis::AxisTypeNone),
+    : m_type(QAbstract3DAxis::AxisTypeNone),
       m_min(0.0f),
       m_max(10.0f),
       m_segmentCount(5),
@@ -51,7 +51,7 @@ void AxisRenderCache::setDrawer(Drawer *drawer)
     }
 }
 
-void AxisRenderCache::setType(Q3DAbstractAxis::AxisType type)
+void AxisRenderCache::setType(QAbstract3DAxis::AxisType type)
 {
     m_type = type;
 
diff --git a/src/datavisualization/engine/axisrendercache_p.h b/src/datavisualization/engine/axisrendercache_p.h
index cddc7839..991cff76 100644
--- a/src/datavisualization/engine/axisrendercache_p.h
+++ b/src/datavisualization/engine/axisrendercache_p.h
@@ -31,7 +31,7 @@
 
 #include "datavisualizationglobal_p.h"
 #include "labelitem_p.h"
-#include "q3dabstractaxis_p.h"
+#include "qabstract3daxis_p.h"
 #include "drawer_p.h"
 
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
@@ -45,8 +45,8 @@ public:
 
     void setDrawer(Drawer *drawer);
 
-    void setType(Q3DAbstractAxis::AxisType type);
-    inline Q3DAbstractAxis::AxisType type() const { return m_type; }
+    void setType(QAbstract3DAxis::AxisType type);
+    inline QAbstract3DAxis::AxisType type() const { return m_type; }
     void setTitle(const QString &title);
     inline const QString &title() { return m_title; }
     void setLabels(const QStringList &labels);
@@ -76,7 +76,7 @@ private:
     int maxLabelWidth(const QStringList &labels) const;
 
     // Cached axis values
-    Q3DAbstractAxis::AxisType m_type;
+    QAbstract3DAxis::AxisType m_type;
     QString m_title;
     QStringList m_labels;
     float m_min;
diff --git a/src/datavisualization/engine/bars3dcontroller.cpp b/src/datavisualization/engine/bars3dcontroller.cpp
index 007fdffc..3efd890b 100644
--- a/src/datavisualization/engine/bars3dcontroller.cpp
+++ b/src/datavisualization/engine/bars3dcontroller.cpp
@@ -19,9 +19,9 @@
 #include "bars3dcontroller_p.h"
 #include "bars3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "q3dabstractaxis_p.h"
-#include "q3dvalueaxis_p.h"
-#include "q3dcategoryaxis_p.h"
+#include "qabstract3daxis_p.h"
+#include "qvalue3daxis_p.h"
+#include "qcategory3daxis_p.h"
 #include "qbardataproxy_p.h"
 #include "qbar3dseries_p.h"
 #include "thememanager_p.h"
@@ -164,7 +164,7 @@ void Bars3DController::handleDataRowLabelsChanged()
         int min = int(m_axisZ->min());
         int count = int(m_axisZ->max()) - min + 1;
         QStringList subList = firstSeries->dataProxy()->rowLabels().mid(min, count);
-        static_cast<Q3DCategoryAxis *>(m_axisZ)->dptr()->setDataLabels(subList);
+        static_cast<QCategory3DAxis *>(m_axisZ)->dptr()->setDataLabels(subList);
     }
 }
 
@@ -179,7 +179,7 @@ void Bars3DController::handleDataColumnLabelsChanged()
         int count = int(m_axisX->max()) - min + 1;
         QStringList subList = static_cast<QBarDataProxy *>(firstSeries->dataProxy())
                 ->columnLabels().mid(min, count);
-        static_cast<Q3DCategoryAxis *>(m_axisX)->dptr()->setDataLabels(subList);
+        static_cast<QCategory3DAxis *>(m_axisX)->dptr()->setDataLabels(subList);
     }
 }
 
@@ -192,7 +192,7 @@ void Bars3DController::handleBarClicked(const QPoint &position, QBar3DSeries *se
 }
 
 void Bars3DController::handleAxisAutoAdjustRangeChangedInOrientation(
-        Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+        QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -214,13 +214,13 @@ QPoint Bars3DController::invalidSelectionPosition()
     return invalidSelectionPos;
 }
 
-void Bars3DController::setAxisX(Q3DAbstractAxis *axis)
+void Bars3DController::setAxisX(QAbstract3DAxis *axis)
 {
     Abstract3DController::setAxisX(axis);
     handleDataColumnLabelsChanged();
 }
 
-void Bars3DController::setAxisZ(Q3DAbstractAxis *axis)
+void Bars3DController::setAxisZ(QAbstract3DAxis *axis)
 {
     Abstract3DController::setAxisZ(axis);
     handleDataRowLabelsChanged();
@@ -385,9 +385,9 @@ void Bars3DController::setSelectedBar(const QPoint &position, QBar3DSeries *seri
 
 void Bars3DController::adjustAxisRanges()
 {
-    Q3DCategoryAxis *categoryAxisZ = static_cast<Q3DCategoryAxis *>(m_axisZ);
-    Q3DCategoryAxis *categoryAxisX = static_cast<Q3DCategoryAxis *>(m_axisX);
-    Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
+    QCategory3DAxis *categoryAxisZ = static_cast<QCategory3DAxis *>(m_axisZ);
+    QCategory3DAxis *categoryAxisX = static_cast<QCategory3DAxis *>(m_axisX);
+    QValue3DAxis *valueAxis = static_cast<QValue3DAxis *>(m_axisY);
 
     bool adjustZ = (categoryAxisZ && categoryAxisZ->isAutoAdjustRange());
     bool adjustX = (categoryAxisX && categoryAxisX->isAutoAdjustRange());
@@ -493,11 +493,11 @@ void Bars3DController::adjustSelectionPosition(QPoint &pos, const QBar3DSeries *
     }
 }
 
-Q3DAbstractAxis *Bars3DController::createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation)
+QAbstract3DAxis *Bars3DController::createDefaultAxis(QAbstract3DAxis::AxisOrientation orientation)
 {
-    Q3DAbstractAxis *defaultAxis = 0;
+    QAbstract3DAxis *defaultAxis = 0;
 
-    if (orientation == Q3DAbstractAxis::AxisOrientationY)
+    if (orientation == QAbstract3DAxis::AxisOrientationY)
         defaultAxis = createDefaultValueAxis();
     else
         defaultAxis = createDefaultCategoryAxis();
diff --git a/src/datavisualization/engine/bars3dcontroller_p.h b/src/datavisualization/engine/bars3dcontroller_p.h
index 54385571..46fc991d 100644
--- a/src/datavisualization/engine/bars3dcontroller_p.h
+++ b/src/datavisualization/engine/bars3dcontroller_p.h
@@ -92,13 +92,13 @@ public:
     void setSelectionMode(QDataVis::SelectionFlags mode);
     void setSelectedBar(const QPoint &position, QBar3DSeries *series);
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust);
     virtual void handleSeriesVisibilityChangedBySender(QObject *sender);
 
     static QPoint invalidSelectionPosition();
 
-    virtual void setAxisX(Q3DAbstractAxis *axis);
-    virtual void setAxisZ(Q3DAbstractAxis *axis);
+    virtual void setAxisX(QAbstract3DAxis *axis);
+    virtual void setAxisZ(QAbstract3DAxis *axis);
 
     virtual void addSeries(QAbstract3DSeries *series);
     virtual void removeSeries(QAbstract3DSeries *series);
@@ -120,7 +120,7 @@ public slots:
     void handleBarClicked(const QPoint &position, QBar3DSeries *series);
 
 protected:
-    virtual Q3DAbstractAxis *createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation);
+    virtual QAbstract3DAxis *createDefaultAxis(QAbstract3DAxis::AxisOrientation orientation);
 
 private:
     void adjustAxisRanges();
diff --git a/src/datavisualization/engine/bars3drenderer.cpp b/src/datavisualization/engine/bars3drenderer.cpp
index f13b6e79..ba9f842c 100644
--- a/src/datavisualization/engine/bars3drenderer.cpp
+++ b/src/datavisualization/engine/bars3drenderer.cpp
@@ -1848,12 +1848,12 @@ void Bars3DRenderer::updateBarSpecs(GLfloat thicknessRatio, const QSizeF &spacin
     calculateSceneScalingFactors();
 }
 
-void Bars3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, float min,
+void Bars3DRenderer::updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min,
                                      float max)
 {
     Abstract3DRenderer::updateAxisRange(orientation, min, max);
 
-    if (orientation == Q3DAbstractAxis::AxisOrientationY) {
+    if (orientation == QAbstract3DAxis::AxisOrientationY) {
         calculateHeightAdjustment();
         // Check if we have negative values
         if (min < 0 && !m_hasNegativeValues) {
diff --git a/src/datavisualization/engine/bars3drenderer_p.h b/src/datavisualization/engine/bars3drenderer_p.h
index 16e7a476..2cdb28e4 100644
--- a/src/datavisualization/engine/bars3drenderer_p.h
+++ b/src/datavisualization/engine/bars3drenderer_p.h
@@ -125,7 +125,7 @@ public slots:
     void updateSelectedBar(const QPoint &position, const QBar3DSeries *series);
 
     // Overloaded from abstract renderer
-    virtual void updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, float min, float max);
+    virtual void updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min, float max);
 
 signals:
     void barClicked(QPoint position, QBar3DSeries *series);
diff --git a/src/datavisualization/engine/q3dbars.cpp b/src/datavisualization/engine/q3dbars.cpp
index 0d711359..d9e265a1 100644
--- a/src/datavisualization/engine/q3dbars.cpp
+++ b/src/datavisualization/engine/q3dbars.cpp
@@ -19,8 +19,8 @@
 #include "q3dbars.h"
 #include "q3dbars_p.h"
 #include "bars3dcontroller_p.h"
-#include "q3dvalueaxis.h"
-#include "q3dcategoryaxis.h"
+#include "qvalue3daxis.h"
+#include "qcategory3daxis.h"
 #include "q3dcamera.h"
 #include "qbar3dseries_p.h"
 
@@ -208,7 +208,7 @@ bool Q3DBars::isBarSpacingRelative()
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setRowAxis(Q3DCategoryAxis *axis)
+void Q3DBars::setRowAxis(QCategory3DAxis *axis)
 {
     dptr()->m_shared->setAxisZ(axis);
 }
@@ -216,9 +216,9 @@ void Q3DBars::setRowAxis(Q3DCategoryAxis *axis)
 /*!
  * \return category axis for rows.
  */
-Q3DCategoryAxis *Q3DBars::rowAxis() const
+QCategory3DAxis *Q3DBars::rowAxis() const
 {
-    return static_cast<Q3DCategoryAxis *>(dptrc()->m_shared->axisZ());
+    return static_cast<QCategory3DAxis *>(dptrc()->m_shared->axisZ());
 }
 
 /*!
@@ -230,7 +230,7 @@ Q3DCategoryAxis *Q3DBars::rowAxis() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setColumnAxis(Q3DCategoryAxis *axis)
+void Q3DBars::setColumnAxis(QCategory3DAxis *axis)
 {
     dptr()->m_shared->setAxisX(axis);
 }
@@ -238,9 +238,9 @@ void Q3DBars::setColumnAxis(Q3DCategoryAxis *axis)
 /*!
  * \return category axis for columns.
  */
-Q3DCategoryAxis *Q3DBars::columnAxis() const
+QCategory3DAxis *Q3DBars::columnAxis() const
 {
-    return static_cast<Q3DCategoryAxis *>(dptrc()->m_shared->axisX());
+    return static_cast<QCategory3DAxis *>(dptrc()->m_shared->axisX());
 }
 
 /*!
@@ -253,7 +253,7 @@ Q3DCategoryAxis *Q3DBars::columnAxis() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setValueAxis(Q3DValueAxis *axis)
+void Q3DBars::setValueAxis(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisY(axis);
 }
@@ -261,9 +261,9 @@ void Q3DBars::setValueAxis(Q3DValueAxis *axis)
 /*!
  * \return used value axis (Y-axis).
  */
-Q3DValueAxis *Q3DBars::valueAxis() const
+QValue3DAxis *Q3DBars::valueAxis() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisY());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisY());
 }
 
 /*!
@@ -273,7 +273,7 @@ Q3DValueAxis *Q3DBars::valueAxis() const
  *
  * \sa releaseAxis(), setValueAxis(), setRowAxis(), setColumnAxis()
  */
-void Q3DBars::addAxis(Q3DAbstractAxis *axis)
+void Q3DBars::addAxis(QAbstract3DAxis *axis)
 {
     dptr()->m_shared->addAxis(axis);
 }
@@ -286,7 +286,7 @@ void Q3DBars::addAxis(Q3DAbstractAxis *axis)
  *
  * \sa addAxis(), setValueAxis(), setRowAxis(), setColumnAxis()
  */
-void Q3DBars::releaseAxis(Q3DAbstractAxis *axis)
+void Q3DBars::releaseAxis(QAbstract3DAxis *axis)
 {
     dptr()->m_shared->releaseAxis(axis);
 }
@@ -296,7 +296,7 @@ void Q3DBars::releaseAxis(Q3DAbstractAxis *axis)
  *
  * \sa addAxis()
  */
-QList<Q3DAbstractAxis *> Q3DBars::axes() const
+QList<QAbstract3DAxis *> Q3DBars::axes() const
 {
     return dptrc()->m_shared->axes();
 }
diff --git a/src/datavisualization/engine/q3dbars.h b/src/datavisualization/engine/q3dbars.h
index 7da446b4..80cd1ba4 100644
--- a/src/datavisualization/engine/q3dbars.h
+++ b/src/datavisualization/engine/q3dbars.h
@@ -27,9 +27,9 @@
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
 
 class Q3DBarsPrivate;
-class Q3DAbstractAxis;
-class Q3DCategoryAxis;
-class Q3DValueAxis;
+class QAbstract3DAxis;
+class QCategory3DAxis;
+class QValue3DAxis;
 class QBar3DSeries;
 
 class QT_DATAVISUALIZATION_EXPORT Q3DBars : public QAbstract3DGraph
@@ -56,15 +56,15 @@ public:
     void setBarSpacingRelative(bool relative);
     bool isBarSpacingRelative();
 
-    void setRowAxis(Q3DCategoryAxis *axis);
-    Q3DCategoryAxis *rowAxis() const;
-    void setColumnAxis(Q3DCategoryAxis *axis);
-    Q3DCategoryAxis *columnAxis() const;
-    void setValueAxis(Q3DValueAxis *axis);
-    Q3DValueAxis *valueAxis() const;
-    void addAxis(Q3DAbstractAxis *axis);
-    void releaseAxis(Q3DAbstractAxis *axis);
-    QList<Q3DAbstractAxis *> axes() const;
+    void setRowAxis(QCategory3DAxis *axis);
+    QCategory3DAxis *rowAxis() const;
+    void setColumnAxis(QCategory3DAxis *axis);
+    QCategory3DAxis *columnAxis() const;
+    void setValueAxis(QValue3DAxis *axis);
+    QValue3DAxis *valueAxis() const;
+    void addAxis(QAbstract3DAxis *axis);
+    void releaseAxis(QAbstract3DAxis *axis);
+    QList<QAbstract3DAxis *> axes() const;
 
 signals:
     void barThicknessChanged(float thicknessRatio);
diff --git a/src/datavisualization/engine/q3dscatter.cpp b/src/datavisualization/engine/q3dscatter.cpp
index aef1e89e..c71ce795 100644
--- a/src/datavisualization/engine/q3dscatter.cpp
+++ b/src/datavisualization/engine/q3dscatter.cpp
@@ -19,7 +19,7 @@
 #include "q3dscatter.h"
 #include "q3dscatter_p.h"
 #include "scatter3dcontroller_p.h"
-#include "q3dvalueaxis.h"
+#include "qvalue3daxis.h"
 #include "q3dcamera.h"
 #include "qscatter3dseries_p.h"
 
@@ -141,7 +141,7 @@ const Q3DScatterPrivate *Q3DScatter::dptrc() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisX(Q3DValueAxis *axis)
+void Q3DScatter::setAxisX(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisX(axis);
 }
@@ -149,9 +149,9 @@ void Q3DScatter::setAxisX(Q3DValueAxis *axis)
 /*!
  * \return used X-axis.
  */
-Q3DValueAxis *Q3DScatter::axisX() const
+QValue3DAxis *Q3DScatter::axisX() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisX());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisX());
 }
 
 /*!
@@ -164,7 +164,7 @@ Q3DValueAxis *Q3DScatter::axisX() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisY(Q3DValueAxis *axis)
+void Q3DScatter::setAxisY(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisY(axis);
 }
@@ -172,9 +172,9 @@ void Q3DScatter::setAxisY(Q3DValueAxis *axis)
 /*!
  * \return used Y-axis.
  */
-Q3DValueAxis *Q3DScatter::axisY() const
+QValue3DAxis *Q3DScatter::axisY() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisY());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisY());
 }
 
 /*!
@@ -187,7 +187,7 @@ Q3DValueAxis *Q3DScatter::axisY() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisZ(Q3DValueAxis *axis)
+void Q3DScatter::setAxisZ(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisZ(axis);
 }
@@ -195,9 +195,9 @@ void Q3DScatter::setAxisZ(Q3DValueAxis *axis)
 /*!
  * \return used Z-axis.
  */
-Q3DValueAxis *Q3DScatter::axisZ() const
+QValue3DAxis *Q3DScatter::axisZ() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisZ());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisZ());
 }
 
 /*!
@@ -207,7 +207,7 @@ Q3DValueAxis *Q3DScatter::axisZ() const
  *
  * \sa releaseAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DScatter::addAxis(Q3DValueAxis *axis)
+void Q3DScatter::addAxis(QValue3DAxis *axis)
 {
     dptr()->m_shared->addAxis(axis);
 }
@@ -220,7 +220,7 @@ void Q3DScatter::addAxis(Q3DValueAxis *axis)
  *
  * \sa addAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DScatter::releaseAxis(Q3DValueAxis *axis)
+void Q3DScatter::releaseAxis(QValue3DAxis *axis)
 {
     dptr()->m_shared->releaseAxis(axis);
 }
@@ -230,12 +230,12 @@ void Q3DScatter::releaseAxis(Q3DValueAxis *axis)
  *
  * \sa addAxis()
  */
-QList<Q3DValueAxis *> Q3DScatter::axes() const
+QList<QValue3DAxis *> Q3DScatter::axes() const
 {
-    QList<Q3DAbstractAxis *> abstractAxes = dptrc()->m_shared->axes();
-    QList<Q3DValueAxis *> retList;
-    foreach (Q3DAbstractAxis *axis, abstractAxes)
-        retList.append(static_cast<Q3DValueAxis *>(axis));
+    QList<QAbstract3DAxis *> abstractAxes = dptrc()->m_shared->axes();
+    QList<QValue3DAxis *> retList;
+    foreach (QAbstract3DAxis *axis, abstractAxes)
+        retList.append(static_cast<QValue3DAxis *>(axis));
 
     return retList;
 }
diff --git a/src/datavisualization/engine/q3dscatter.h b/src/datavisualization/engine/q3dscatter.h
index f6f3dd2f..8a94864e 100644
--- a/src/datavisualization/engine/q3dscatter.h
+++ b/src/datavisualization/engine/q3dscatter.h
@@ -28,8 +28,8 @@
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
 
 class Q3DScatterPrivate;
-class Q3DValueAxis;
-class Q3DCategoryAxis;
+class QValue3DAxis;
+class QCategory3DAxis;
 class QScatter3DSeries;
 
 class QT_DATAVISUALIZATION_EXPORT Q3DScatter : public QAbstract3DGraph
@@ -43,15 +43,15 @@ public:
     void removeSeries(QScatter3DSeries *series);
     QList<QScatter3DSeries *> seriesList();
 
-    void setAxisX(Q3DValueAxis *axis);
-    Q3DValueAxis *axisX() const;
-    void setAxisY(Q3DValueAxis *axis);
-    Q3DValueAxis *axisY() const;
-    void setAxisZ(Q3DValueAxis *axis);
-    Q3DValueAxis *axisZ() const;
-    void addAxis(Q3DValueAxis *axis);
-    void releaseAxis(Q3DValueAxis *axis);
-    QList<Q3DValueAxis *> axes() const;
+    void setAxisX(QValue3DAxis *axis);
+    QValue3DAxis *axisX() const;
+    void setAxisY(QValue3DAxis *axis);
+    QValue3DAxis *axisY() const;
+    void setAxisZ(QValue3DAxis *axis);
+    QValue3DAxis *axisZ() const;
+    void addAxis(QValue3DAxis *axis);
+    void releaseAxis(QValue3DAxis *axis);
+    QList<QValue3DAxis *> axes() const;
 
 private:
     Q3DScatterPrivate *dptr();
diff --git a/src/datavisualization/engine/q3dsurface.cpp b/src/datavisualization/engine/q3dsurface.cpp
index 0df5a9bb..0b09aba4 100644
--- a/src/datavisualization/engine/q3dsurface.cpp
+++ b/src/datavisualization/engine/q3dsurface.cpp
@@ -18,7 +18,7 @@
 
 #include "q3dsurface.h"
 #include "q3dsurface_p.h"
-#include "q3dvalueaxis.h"
+#include "qvalue3daxis.h"
 #include "qsurfacedataproxy.h"
 #include "q3dcamera.h"
 #include "qsurface3dseries_p.h"
@@ -40,7 +40,7 @@ QT_DATAVISUALIZATION_BEGIN_NAMESPACE
  * The selection pointer is accompanied with a label which in default case shows the value of the
  * data point and the coordinates of the point.
  *
- * The value range and the label format shown on the axis can be controlled through Q3DValueAxis.
+ * The value range and the label format shown on the axis can be controlled through QValue3DAxis.
  *
  * To rotate the graph, hold down the right mouse button and move the mouse. Zooming is done using mouse
  * wheel. Both assume the default input handler is in use.
@@ -156,7 +156,7 @@ const Q3DSurfacePrivate *Q3DSurface::dptrc() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisX(Q3DValueAxis *axis)
+void Q3DSurface::setAxisX(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisX(axis);
 }
@@ -164,9 +164,9 @@ void Q3DSurface::setAxisX(Q3DValueAxis *axis)
 /*!
  * \return used X-axis.
  */
-Q3DValueAxis *Q3DSurface::axisX() const
+QValue3DAxis *Q3DSurface::axisX() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisX());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisX());
 }
 
 /*!
@@ -179,7 +179,7 @@ Q3DValueAxis *Q3DSurface::axisX() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisY(Q3DValueAxis *axis)
+void Q3DSurface::setAxisY(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisY(axis);
 }
@@ -187,9 +187,9 @@ void Q3DSurface::setAxisY(Q3DValueAxis *axis)
 /*!
  * \return used Y-axis.
  */
-Q3DValueAxis *Q3DSurface::axisY() const
+QValue3DAxis *Q3DSurface::axisY() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisY());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisY());
 }
 
 /*!
@@ -202,7 +202,7 @@ Q3DValueAxis *Q3DSurface::axisY() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisZ(Q3DValueAxis *axis)
+void Q3DSurface::setAxisZ(QValue3DAxis *axis)
 {
     dptr()->m_shared->setAxisZ(axis);
 }
@@ -210,9 +210,9 @@ void Q3DSurface::setAxisZ(Q3DValueAxis *axis)
 /*!
  * \return used Z-axis.
  */
-Q3DValueAxis *Q3DSurface::axisZ() const
+QValue3DAxis *Q3DSurface::axisZ() const
 {
-    return static_cast<Q3DValueAxis *>(dptrc()->m_shared->axisZ());
+    return static_cast<QValue3DAxis *>(dptrc()->m_shared->axisZ());
 }
 
 /*!
@@ -222,7 +222,7 @@ Q3DValueAxis *Q3DSurface::axisZ() const
  *
  * \sa releaseAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DSurface::addAxis(Q3DValueAxis *axis)
+void Q3DSurface::addAxis(QValue3DAxis *axis)
 {
     dptr()->m_shared->addAxis(axis);
 }
@@ -235,7 +235,7 @@ void Q3DSurface::addAxis(Q3DValueAxis *axis)
  *
  * \sa addAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DSurface::releaseAxis(Q3DValueAxis *axis)
+void Q3DSurface::releaseAxis(QValue3DAxis *axis)
 {
     dptr()->m_shared->releaseAxis(axis);
 }
@@ -245,12 +245,12 @@ void Q3DSurface::releaseAxis(Q3DValueAxis *axis)
  *
  * \sa addAxis()
  */
-QList<Q3DValueAxis *> Q3DSurface::axes() const
+QList<QValue3DAxis *> Q3DSurface::axes() const
 {
-    QList<Q3DAbstractAxis *> abstractAxes = dptrc()->m_shared->axes();
-    QList<Q3DValueAxis *> retList;
-    foreach (Q3DAbstractAxis *axis, abstractAxes)
-        retList.append(static_cast<Q3DValueAxis *>(axis));
+    QList<QAbstract3DAxis *> abstractAxes = dptrc()->m_shared->axes();
+    QList<QValue3DAxis *> retList;
+    foreach (QAbstract3DAxis *axis, abstractAxes)
+        retList.append(static_cast<QValue3DAxis *>(axis));
 
     return retList;
 }
diff --git a/src/datavisualization/engine/q3dsurface.h b/src/datavisualization/engine/q3dsurface.h
index 822e9d7c..4d6bcf5e 100644
--- a/src/datavisualization/engine/q3dsurface.h
+++ b/src/datavisualization/engine/q3dsurface.h
@@ -27,7 +27,7 @@
 QT_DATAVISUALIZATION_BEGIN_NAMESPACE
 
 class Q3DSurfacePrivate;
-class Q3DValueAxis;
+class QValue3DAxis;
 class QSurface3DSeries;
 
 class QT_DATAVISUALIZATION_EXPORT Q3DSurface : public QAbstract3DGraph
@@ -42,15 +42,15 @@ public:
     QList<QSurface3DSeries *> seriesList();
 
     // Axes
-    void setAxisX(Q3DValueAxis *axis);
-    Q3DValueAxis *axisX() const;
-    void setAxisY(Q3DValueAxis *axis);
-    Q3DValueAxis *axisY() const;
-    void setAxisZ(Q3DValueAxis *axis);
-    Q3DValueAxis *axisZ() const;
-    void addAxis(Q3DValueAxis *axis);
-    void releaseAxis(Q3DValueAxis *axis);
-    QList<Q3DValueAxis *> axes() const;
+    void setAxisX(QValue3DAxis *axis);
+    QValue3DAxis *axisX() const;
+    void setAxisY(QValue3DAxis *axis);
+    QValue3DAxis *axisY() const;
+    void setAxisZ(QValue3DAxis *axis);
+    QValue3DAxis *axisZ() const;
+    void addAxis(QValue3DAxis *axis);
+    void releaseAxis(QValue3DAxis *axis);
+    QList<QValue3DAxis *> axes() const;
 
 private:
     Q3DSurfacePrivate *dptr();
diff --git a/src/datavisualization/engine/scatter3dcontroller.cpp b/src/datavisualization/engine/scatter3dcontroller.cpp
index 0a506f19..61a95e88 100644
--- a/src/datavisualization/engine/scatter3dcontroller.cpp
+++ b/src/datavisualization/engine/scatter3dcontroller.cpp
@@ -19,8 +19,8 @@
 #include "scatter3dcontroller_p.h"
 #include "scatter3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "q3dabstractaxis_p.h"
-#include "q3dvalueaxis_p.h"
+#include "qabstract3daxis_p.h"
+#include "qvalue3daxis_p.h"
 #include "qscatterdataproxy_p.h"
 #include "qscatter3dseries_p.h"
 
@@ -179,7 +179,7 @@ void Scatter3DController::handleItemClicked(int index, QScatter3DSeries *series)
 }
 
 void Scatter3DController::handleAxisAutoAdjustRangeChangedInOrientation(
-        Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+        QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -239,9 +239,9 @@ void Scatter3DController::setSelectedItem(int index, QScatter3DSeries *series)
 
 void Scatter3DController::adjustValueAxisRange()
 {
-    Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
-    Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
-    Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+    QValue3DAxis *valueAxisX = static_cast<QValue3DAxis *>(m_axisX);
+    QValue3DAxis *valueAxisY = static_cast<QValue3DAxis *>(m_axisY);
+    QValue3DAxis *valueAxisZ = static_cast<QValue3DAxis *>(m_axisZ);
     bool adjustX = (valueAxisX && valueAxisX->isAutoAdjustRange());
     bool adjustY = (valueAxisY && valueAxisY->isAutoAdjustRange());
     bool adjustZ = (valueAxisZ && valueAxisZ->isAutoAdjustRange());
diff --git a/src/datavisualization/engine/scatter3dcontroller_p.h b/src/datavisualization/engine/scatter3dcontroller_p.h
index 00c87d4f..397d47a4 100644
--- a/src/datavisualization/engine/scatter3dcontroller_p.h
+++ b/src/datavisualization/engine/scatter3dcontroller_p.h
@@ -80,7 +80,7 @@ public:
     virtual void removeSeries(QAbstract3DSeries *series);
     virtual QList<QScatter3DSeries *> scatterSeriesList();
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust);
     virtual void handleAxisRangeChangedBySender(QObject *sender);
 
 public slots:
diff --git a/src/datavisualization/engine/scatter3drenderer.cpp b/src/datavisualization/engine/scatter3drenderer.cpp
index ee5c119e..b70fd5b4 100644
--- a/src/datavisualization/engine/scatter3drenderer.cpp
+++ b/src/datavisualization/engine/scatter3drenderer.cpp
@@ -1621,7 +1621,7 @@ void Scatter3DRenderer::fixMeshFileName(QString &fileName, QAbstract3DSeries::Me
     }
 }
 
-void Scatter3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation,
+void Scatter3DRenderer::updateAxisRange(QAbstract3DAxis::AxisOrientation orientation,
                                         float min, float max)
 {
     Abstract3DRenderer::updateAxisRange(orientation, min, max);
diff --git a/src/datavisualization/engine/scatter3drenderer_p.h b/src/datavisualization/engine/scatter3drenderer_p.h
index 30ec7489..9153d80a 100644
--- a/src/datavisualization/engine/scatter3drenderer_p.h
+++ b/src/datavisualization/engine/scatter3drenderer_p.h
@@ -137,7 +137,7 @@ private:
 
 public slots:
     // Overloaded from abstract renderer
-    virtual void updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, float min, float max);
+    virtual void updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min, float max);
 
     void updateSelectedItem(int index, const QScatter3DSeries *series);
 
diff --git a/src/datavisualization/engine/surface3dcontroller.cpp b/src/datavisualization/engine/surface3dcontroller.cpp
index 3cec72d1..6082e105 100644
--- a/src/datavisualization/engine/surface3dcontroller.cpp
+++ b/src/datavisualization/engine/surface3dcontroller.cpp
@@ -19,9 +19,9 @@
 #include "surface3dcontroller_p.h"
 #include "surface3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "q3dabstractaxis_p.h"
-#include "q3dvalueaxis_p.h"
-#include "q3dcategoryaxis.h"
+#include "qabstract3daxis_p.h"
+#include "qvalue3daxis_p.h"
+#include "qcategory3daxis.h"
 #include "qsurfacedataproxy_p.h"
 #include "qsurface3dseries_p.h"
 #include "shaderhelper_p.h"
@@ -91,7 +91,7 @@ void Surface3DController::synchDataToRenderer()
     }
 }
 
-void Surface3DController::handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+void Surface3DController::handleAxisAutoAdjustRangeChangedInOrientation(QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -383,9 +383,9 @@ void Surface3DController::handleRowsRemoved(int startIndex, int count)
 
 void Surface3DController::adjustValueAxisRange()
 {
-    Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
-    Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
-    Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+    QValue3DAxis *valueAxisX = static_cast<QValue3DAxis *>(m_axisX);
+    QValue3DAxis *valueAxisY = static_cast<QValue3DAxis *>(m_axisY);
+    QValue3DAxis *valueAxisZ = static_cast<QValue3DAxis *>(m_axisZ);
     bool adjustX = (valueAxisX && valueAxisX->isAutoAdjustRange());
     bool adjustY = (valueAxisY && valueAxisY->isAutoAdjustRange());
     bool adjustZ = (valueAxisZ && valueAxisZ->isAutoAdjustRange());
diff --git a/src/datavisualization/engine/surface3dcontroller_p.h b/src/datavisualization/engine/surface3dcontroller_p.h
index 714420a4..54d709b4 100644
--- a/src/datavisualization/engine/surface3dcontroller_p.h
+++ b/src/datavisualization/engine/surface3dcontroller_p.h
@@ -79,7 +79,7 @@ public:
     void setSelectionMode(QDataVis::SelectionFlags mode);
     void setSelectedPoint(const QPoint &position, QSurface3DSeries *series);
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust);
     virtual void handleAxisRangeChangedBySender(QObject *sender);
     virtual void handleSeriesVisibilityChangedBySender(QObject *sender);