Rename axes to avoid conflicts with Charts

+ Some doc fixes.

Task-number: QTRD-2214
Change-Id: Idecec749a76ef6a5d84857d1396f25be3ef017ca
Reviewed-by: Tomi Korpipää <tomi.korpipaa@digia.com>

22 files changed, 243 insertions, 243 deletions

diff --git a/src/datavis3d/engine/abstract3dcontroller.cpp b/src/datavis3d/engine/abstract3dcontroller.cpp
index b85fb976..23781624 100644
--- a/src/datavis3d/engine/abstract3dcontroller.cpp
+++ b/src/datavis3d/engine/abstract3dcontroller.cpp
@@ -18,9 +18,9 @@
 
 #include "abstract3dcontroller_p.h"
 #include "camerahelper_p.h"
-#include "qabstractaxis_p.h"
-#include "qvalueaxis.h"
-#include "qcategoryaxis.h"
+#include "q3dabstractaxis_p.h"
+#include "q3dvalueaxis.h"
+#include "q3dcategoryaxis.h"
 #include "abstract3drenderer_p.h"
 #include "qabstractdataproxy_p.h"
 
@@ -139,153 +139,153 @@ void Abstract3DController::synchDataToRenderer()
     }
 
     if (m_changeTracker.axisXTypeChanged) {
-        m_renderer->updateAxisType(QAbstractAxis::AxisOrientationX, m_axisX->type());
+        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationX, m_axisX->type());
         m_changeTracker.axisXTypeChanged = false;
     }
 
     if (m_changeTracker.axisYTypeChanged) {
-        m_renderer->updateAxisType(QAbstractAxis::AxisOrientationY, m_axisY->type());
+        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationY, m_axisY->type());
         m_changeTracker.axisYTypeChanged = false;
     }
 
     if (m_changeTracker.axisZTypeChanged) {
-        m_renderer->updateAxisType(QAbstractAxis::AxisOrientationZ, m_axisZ->type());
+        m_renderer->updateAxisType(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->type());
         m_changeTracker.axisZTypeChanged = false;
     }
 
     if (m_changeTracker.axisXTitleChanged) {
-        m_renderer->updateAxisTitle(QAbstractAxis::AxisOrientationX, m_axisX->title());
+        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationX, m_axisX->title());
         m_changeTracker.axisXTitleChanged = false;
     }
 
     if (m_changeTracker.axisYTitleChanged) {
-        m_renderer->updateAxisTitle(QAbstractAxis::AxisOrientationY, m_axisY->title());
+        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationY, m_axisY->title());
         m_changeTracker.axisYTitleChanged = false;
     }
 
     if (m_changeTracker.axisZTitleChanged) {
-        m_renderer->updateAxisTitle(QAbstractAxis::AxisOrientationZ, m_axisZ->title());
+        m_renderer->updateAxisTitle(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->title());
         m_changeTracker.axisZTitleChanged = false;
     }
 
     if (m_changeTracker.axisXLabelsChanged) {
-        m_renderer->updateAxisLabels(QAbstractAxis::AxisOrientationX, m_axisX->labels());
+        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationX, m_axisX->labels());
         m_changeTracker.axisXLabelsChanged = false;
     }
 
     if (m_changeTracker.axisYLabelsChanged) {
-        m_renderer->updateAxisLabels(QAbstractAxis::AxisOrientationY, m_axisY->labels());
+        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationY, m_axisY->labels());
         m_changeTracker.axisYLabelsChanged = false;
     }
     if (m_changeTracker.axisZLabelsChanged) {
-        m_renderer->updateAxisLabels(QAbstractAxis::AxisOrientationZ, m_axisZ->labels());
+        m_renderer->updateAxisLabels(Q3DAbstractAxis::AxisOrientationZ, m_axisZ->labels());
         m_changeTracker.axisZLabelsChanged = false;
     }
 
     if (m_changeTracker.axisXRangeChanged) {
         m_changeTracker.axisXRangeChanged = false;
-        if (m_axisX->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisX = static_cast<QValueAxis *>(m_axisX);
-            m_renderer->updateAxisRange(QAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+            m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationX,
                                         valueAxisX->min(), valueAxisX->max());
         }
     }
 
     if (m_changeTracker.axisYRangeChanged) {
         m_changeTracker.axisYRangeChanged = false;
-        if (m_axisY->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisY = static_cast<QValueAxis *>(m_axisY);
-            m_renderer->updateAxisRange(QAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+            m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationY,
                                         valueAxisY->min(), valueAxisY->max());
         }
     }
 
     if (m_changeTracker.axisZRangeChanged) {
         m_changeTracker.axisZRangeChanged = false;
-        if (m_axisZ->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisZ = static_cast<QValueAxis *>(m_axisZ);
-            m_renderer->updateAxisRange(QAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+            m_renderer->updateAxisRange(Q3DAbstractAxis::AxisOrientationZ,
                                         valueAxisZ->min(), valueAxisZ->max());
         }
     }
 
     if (m_changeTracker.axisXSegmentCountChanged) {
         m_changeTracker.axisXSegmentCountChanged = false;
-        if (m_axisX->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisX = static_cast<QValueAxis *>(m_axisX);
-            m_renderer->updateAxisSegmentCount(QAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationX,
                                                valueAxisX->segmentCount());
         }
     }
 
     if (m_changeTracker.axisYSegmentCountChanged) {
         m_changeTracker.axisYSegmentCountChanged = false;
-        if (m_axisY->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisY = static_cast<QValueAxis *>(m_axisY);
-            m_renderer->updateAxisSegmentCount(QAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationY,
                                                valueAxisY->segmentCount());
         }
     }
 
     if (m_changeTracker.axisZSegmentCountChanged) {
         m_changeTracker.axisZSegmentCountChanged = false;
-        if (m_axisZ->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisZ = static_cast<QValueAxis *>(m_axisZ);
-            m_renderer->updateAxisSegmentCount(QAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+            m_renderer->updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientationZ,
                                                valueAxisZ->segmentCount());
         }
     }
 
     if (m_changeTracker.axisXSubSegmentCountChanged) {
         m_changeTracker.axisXSubSegmentCountChanged = false;
-        if (m_axisX->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisX = static_cast<QValueAxis *>(m_axisX);
-            m_renderer->updateAxisSubSegmentCount(QAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationX,
                                                   valueAxisX->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisYSubSegmentCountChanged) {
         m_changeTracker.axisYSubSegmentCountChanged = false;
-        if (m_axisY->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisY = static_cast<QValueAxis *>(m_axisY);
-            m_renderer->updateAxisSubSegmentCount(QAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationY,
                                                   valueAxisY->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisZSubSegmentCountChanged) {
         m_changeTracker.axisZSubSegmentCountChanged = false;
-        if (m_axisZ->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisZ = static_cast<QValueAxis *>(m_axisZ);
-            m_renderer->updateAxisSubSegmentCount(QAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+            m_renderer->updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientationZ,
                                                   valueAxisZ->subSegmentCount());
         }
     }
 
     if (m_changeTracker.axisXLabelFormatChanged) {
         m_changeTracker.axisXLabelFormatChanged = false;
-        if (m_axisX->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisX = static_cast<QValueAxis *>(m_axisX);
-            m_renderer->updateAxisLabelFormat(QAbstractAxis::AxisOrientationX,
+        if (m_axisX->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationX,
                                               valueAxisX->labelFormat());
         }
     }
 
     if (m_changeTracker.axisYLabelFormatChanged) {
         m_changeTracker.axisYLabelFormatChanged = false;
-        if (m_axisY->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisY = static_cast<QValueAxis *>(m_axisY);
-            m_renderer->updateAxisLabelFormat(QAbstractAxis::AxisOrientationY,
+        if (m_axisY->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationY,
                                               valueAxisY->labelFormat());
         }
     }
 
     if (m_changeTracker.axisZLabelFormatChanged) {
         m_changeTracker.axisZLabelFormatChanged = false;
-        if (m_axisZ->type() & QAbstractAxis::AxisTypeValue) {
-            QValueAxis *valueAxisZ = static_cast<QValueAxis *>(m_axisZ);
-            m_renderer->updateAxisLabelFormat(QAbstractAxis::AxisOrientationZ,
+        if (m_axisZ->type() & Q3DAbstractAxis::AxisTypeValue) {
+            Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+            m_renderer->updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientationZ,
                                               valueAxisZ->labelFormat());
         }
     }
@@ -386,37 +386,37 @@ int Abstract3DController::y()
     return m_boundingRect.y();
 }
 
-void Abstract3DController::setAxisX(QAbstractAxis *axis)
+void Abstract3DController::setAxisX(Q3DAbstractAxis *axis)
 {
-    setAxisHelper(QAbstractAxis::AxisOrientationX, axis, &m_axisX);
+    setAxisHelper(Q3DAbstractAxis::AxisOrientationX, axis, &m_axisX);
 }
 
-QAbstractAxis *Abstract3DController::axisX()
+Q3DAbstractAxis *Abstract3DController::axisX()
 {
     return m_axisX;
 }
 
-void Abstract3DController::setAxisY(QAbstractAxis *axis)
+void Abstract3DController::setAxisY(Q3DAbstractAxis *axis)
 {
-    setAxisHelper(QAbstractAxis::AxisOrientationY, axis, &m_axisY);
+    setAxisHelper(Q3DAbstractAxis::AxisOrientationY, axis, &m_axisY);
 }
 
-QAbstractAxis *Abstract3DController::axisY()
+Q3DAbstractAxis *Abstract3DController::axisY()
 {
     return m_axisY;
 }
 
-void Abstract3DController::setAxisZ(QAbstractAxis *axis)
+void Abstract3DController::setAxisZ(Q3DAbstractAxis *axis)
 {
-    setAxisHelper(QAbstractAxis::AxisOrientationZ, axis, &m_axisZ);
+    setAxisHelper(Q3DAbstractAxis::AxisOrientationZ, axis, &m_axisZ);
 }
 
-QAbstractAxis *Abstract3DController::axisZ()
+Q3DAbstractAxis *Abstract3DController::axisZ()
 {
     return m_axisZ;
 }
 
-void Abstract3DController::addAxis(QAbstractAxis *axis)
+void Abstract3DController::addAxis(Q3DAbstractAxis *axis)
 {
     Q_ASSERT(axis);
     Abstract3DController *owner = qobject_cast<Abstract3DController *>(axis->parent());
@@ -428,7 +428,7 @@ void Abstract3DController::addAxis(QAbstractAxis *axis)
         m_axes.append(axis);
 }
 
-void Abstract3DController::releaseAxis(QAbstractAxis *axis)
+void Abstract3DController::releaseAxis(Q3DAbstractAxis *axis)
 {
     if (axis && m_axes.contains(axis)) {
         // Clear the default status from released default axes
@@ -437,13 +437,13 @@ void Abstract3DController::releaseAxis(QAbstractAxis *axis)
 
         // If the axis is in use, replace it with a temporary one
         switch (axis->orientation()) {
-        case QAbstractAxis::AxisOrientationX:
+        case Q3DAbstractAxis::AxisOrientationX:
             setAxisX(0);
             break;
-        case QAbstractAxis::AxisOrientationY:
+        case Q3DAbstractAxis::AxisOrientationY:
             setAxisY(0);
             break;
-        case QAbstractAxis::AxisOrientationZ:
+        case Q3DAbstractAxis::AxisOrientationZ:
             setAxisZ(0);
             break;
         default:
@@ -455,7 +455,7 @@ void Abstract3DController::releaseAxis(QAbstractAxis *axis)
     }
 }
 
-QList<QAbstractAxis *> Abstract3DController::axes() const
+QList<Q3DAbstractAxis *> Abstract3DController::axes() const
 {
     return m_axes;
 }
@@ -767,7 +767,7 @@ void Abstract3DController::handleAxisAutoAdjustRangeChanged(bool autoAdjust)
     if (sender != m_axisX && sender != m_axisY && sender != m_axisZ)
         return;
 
-    QAbstractAxis *axis = static_cast<QAbstractAxis*>(sender);
+    Q3DAbstractAxis *axis = static_cast<Q3DAbstractAxis*>(sender);
     handleAxisAutoAdjustRangeChangedInOrientation(axis->orientation(), autoAdjust);
 }
 
@@ -795,15 +795,15 @@ void Abstract3DController::handleAxisLabelFormatChangedBySender(QObject *sender)
     emitNeedRender();
 }
 
-void Abstract3DController::setAxisHelper(QAbstractAxis::AxisOrientation orientation,
-                                         QAbstractAxis *axis, QAbstractAxis **axisPtr)
+void Abstract3DController::setAxisHelper(Q3DAbstractAxis::AxisOrientation orientation,
+                                         Q3DAbstractAxis *axis, Q3DAbstractAxis **axisPtr)
 {
     // Setting null axis indicates using default axis
     if (!axis)
         axis = createDefaultAxis(orientation);
 
     // If old axis is default axis, delete it
-    QAbstractAxis *oldAxis = *axisPtr;
+    Q3DAbstractAxis *oldAxis = *axisPtr;
     if (oldAxis) {
         if (oldAxis->d_ptr->isDefaultAxis()) {
             m_axes.removeAll(oldAxis);
@@ -812,7 +812,7 @@ void Abstract3DController::setAxisHelper(QAbstractAxis::AxisOrientation orientat
         } else {
             // Disconnect the old axis from use
             QObject::disconnect(oldAxis, 0, this, 0);
-            oldAxis->d_ptr->setOrientation(QAbstractAxis::AxisOrientationNone);
+            oldAxis->d_ptr->setOrientation(Q3DAbstractAxis::AxisOrientationNone);
         }
     }
 
@@ -824,32 +824,32 @@ void Abstract3DController::setAxisHelper(QAbstractAxis::AxisOrientation orientat
 
     axis->d_ptr->setOrientation(orientation);
 
-    QObject::connect(axis, &QAbstractAxis::titleChanged,
+    QObject::connect(axis, &Q3DAbstractAxis::titleChanged,
                      this, &Abstract3DController::handleAxisTitleChanged);
-    QObject::connect(axis, &QAbstractAxis::labelsChanged,
+    QObject::connect(axis, &Q3DAbstractAxis::labelsChanged,
                      this, &Abstract3DController::handleAxisLabelsChanged);
 
-    if (orientation == QAbstractAxis::AxisOrientationX)
+    if (orientation == Q3DAbstractAxis::AxisOrientationX)
         m_changeTracker.axisXTypeChanged = true;
-    else if (orientation == QAbstractAxis::AxisOrientationY)
+    else if (orientation == Q3DAbstractAxis::AxisOrientationY)
         m_changeTracker.axisYTypeChanged = true;
-    else if (orientation == QAbstractAxis::AxisOrientationZ)
+    else if (orientation == Q3DAbstractAxis::AxisOrientationZ)
         m_changeTracker.axisZTypeChanged = true;
 
     handleAxisTitleChangedBySender(axis);
     handleAxisLabelsChangedBySender(axis);
 
-    if (axis->type() & QAbstractAxis::AxisTypeValue) {
-        QValueAxis *valueAxis = static_cast<QValueAxis *>(axis);
-        QObject::connect(valueAxis, &QValueAxis::rangeChanged,
+    if (axis->type() & Q3DAbstractAxis::AxisTypeValue) {
+        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(axis);
+        QObject::connect(valueAxis, &Q3DValueAxis::rangeChanged,
                          this, &Abstract3DController::handleAxisRangeChanged);
-        QObject::connect(valueAxis, &QValueAxis::segmentCountChanged,
+        QObject::connect(valueAxis, &Q3DValueAxis::segmentCountChanged,
                          this, &Abstract3DController::handleAxisSegmentCountChanged);
-        QObject::connect(valueAxis, &QValueAxis::subSegmentCountChanged,
+        QObject::connect(valueAxis, &Q3DValueAxis::subSegmentCountChanged,
                          this, &Abstract3DController::handleAxisSubSegmentCountChanged);
-        QObject::connect(valueAxis, &QValueAxis::autoAdjustRangeChanged,
+        QObject::connect(valueAxis, &Q3DValueAxis::autoAdjustRangeChanged,
                          this, &Abstract3DController::handleAxisAutoAdjustRangeChanged);
-        QObject::connect(valueAxis, &QValueAxis::labelFormatChanged,
+        QObject::connect(valueAxis, &Q3DValueAxis::labelFormatChanged,
                          this, &Abstract3DController::handleAxisLabelFormatChanged);
 
         handleAxisRangeChangedBySender(valueAxis);
@@ -861,21 +861,21 @@ void Abstract3DController::setAxisHelper(QAbstractAxis::AxisOrientation orientat
     }
 }
 
-QAbstractAxis *Abstract3DController::createDefaultAxis(QAbstractAxis::AxisOrientation orientation)
+Q3DAbstractAxis *Abstract3DController::createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation)
 {
     Q_UNUSED(orientation)
 
     // The default default axis is a value axis. If the chart type has a different default axis
     // for some orientation, this function needs to be overridden.
-    QAbstractAxis *defaultAxis = createDefaultValueAxis();
+    Q3DAbstractAxis *defaultAxis = createDefaultValueAxis();
     return defaultAxis;
 }
 
-QValueAxis *Abstract3DController::createDefaultValueAxis()
+Q3DValueAxis *Abstract3DController::createDefaultValueAxis()
 {
     // Default value axis has single segment, empty label format, and auto scaling
     // TODO: Grid should be also hidden, but that is not currently controlled by axis
-    QValueAxis *defaultAxis = new QValueAxis;
+    Q3DValueAxis *defaultAxis = new Q3DValueAxis;
     defaultAxis->setSegmentCount(1);
     defaultAxis->setSubSegmentCount(1);
     defaultAxis->setAutoAdjustRange(true);
@@ -885,11 +885,11 @@ QValueAxis *Abstract3DController::createDefaultValueAxis()
     return defaultAxis;
 }
 
-QCategoryAxis *Abstract3DController::createDefaultCategoryAxis()
+Q3DCategoryAxis *Abstract3DController::createDefaultCategoryAxis()
 {
     // Default category axis has no labels
     // TODO: Grid should be also hidden, but that is not currently controlled by axis.
-    QCategoryAxis *defaultAxis = new QCategoryAxis;
+    Q3DCategoryAxis *defaultAxis = new Q3DCategoryAxis;
     defaultAxis->d_ptr->setDefaultAxis(true);
     return defaultAxis;
 }
diff --git a/src/datavis3d/engine/abstract3dcontroller_p.h b/src/datavis3d/engine/abstract3dcontroller_p.h
index 5225c686..83ea8379 100644
--- a/src/datavis3d/engine/abstract3dcontroller_p.h
+++ b/src/datavis3d/engine/abstract3dcontroller_p.h
@@ -33,7 +33,7 @@
 
 #include "datavis3dglobal_p.h"
 #include "theme_p.h"
-#include "qabstractaxis.h"
+#include "q3dabstractaxis.h"
 #include "drawer_p.h"
 #include "qabstract3dinputhandler.h"
 #include "qabstractdataproxy.h"
@@ -158,11 +158,11 @@ protected:
     CameraHelper *m_cameraHelper;
     int m_zoomLevel;
     // Active axes
-    QAbstractAxis *m_axisX;
-    QAbstractAxis *m_axisY;
-    QAbstractAxis *m_axisZ;
+    Q3DAbstractAxis *m_axisX;
+    Q3DAbstractAxis *m_axisY;
+    Q3DAbstractAxis *m_axisZ;
 
-    QList<QAbstractAxis *> m_axes; // List of all added axes
+    QList<Q3DAbstractAxis *> m_axes; // List of all added axes
     Abstract3DRenderer *m_renderer;
     bool m_isDataDirty;
 
@@ -204,15 +204,15 @@ public:
     virtual int x();
     virtual void setY(const int y);
     virtual int y();
-    virtual void setAxisX(QAbstractAxis *axis);
-    virtual QAbstractAxis *axisX();
-    virtual void setAxisY(QAbstractAxis *axis);
-    virtual QAbstractAxis *axisY();
-    virtual void setAxisZ(QAbstractAxis *axis);
-    virtual QAbstractAxis *axisZ();
-    virtual void addAxis(QAbstractAxis *axis);
-    virtual void releaseAxis(QAbstractAxis *axis);
-    virtual QList<QAbstractAxis *> axes() const; // Omits default axes
+    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 QAbstractDataProxy *activeDataProxy() const;
     virtual void addDataProxy(QAbstractDataProxy *proxy);
@@ -275,7 +275,7 @@ public:
     virtual void handleAxisSegmentCountChangedBySender(QObject *sender);
     virtual void handleAxisSubSegmentCountChangedBySender(QObject *sender);
     virtual void handleAxisAutoAdjustRangeChangedInOrientation(
-            QAbstractAxis::AxisOrientation orientation, bool autoAdjust) = 0;
+            Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust) = 0;
     virtual void handleAxisLabelFormatChangedBySender(QObject *sender);
 
 public slots:
@@ -293,14 +293,14 @@ signals:
     void needRender();
 
 protected:
-    virtual QAbstractAxis *createDefaultAxis(QAbstractAxis::AxisOrientation orientation);
-    QValueAxis *createDefaultValueAxis();
-    QCategoryAxis *createDefaultCategoryAxis();
+    virtual Q3DAbstractAxis *createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation);
+    Q3DValueAxis *createDefaultValueAxis();
+    Q3DCategoryAxis *createDefaultCategoryAxis();
     void emitNeedRender();
 
 private:
-    void setAxisHelper(QAbstractAxis::AxisOrientation orientation, QAbstractAxis *axis,
-                       QAbstractAxis **axisPtr);
+    void setAxisHelper(Q3DAbstractAxis::AxisOrientation orientation, Q3DAbstractAxis *axis,
+                       Q3DAbstractAxis **axisPtr);
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/abstract3drenderer.cpp b/src/datavis3d/engine/abstract3drenderer.cpp
index 73e4ace6..fe0f10c4 100644
--- a/src/datavis3d/engine/abstract3drenderer.cpp
+++ b/src/datavis3d/engine/abstract3drenderer.cpp
@@ -17,7 +17,7 @@
 ****************************************************************************/
 
 #include "abstract3drenderer_p.h"
-#include "qvalueaxis.h"
+#include "q3dvalueaxis.h"
 #include "texturehelper_p.h"
 #include "utils_p.h"
 
@@ -70,9 +70,9 @@ void Abstract3DRenderer::initializeOpenGL()
     m_textureHelper = new TextureHelper();
     m_drawer->initializeOpenGL();
 
-    axisCacheForOrientation(QAbstractAxis::AxisOrientationX).setDrawer(m_drawer);
-    axisCacheForOrientation(QAbstractAxis::AxisOrientationY).setDrawer(m_drawer);
-    axisCacheForOrientation(QAbstractAxis::AxisOrientationZ).setDrawer(m_drawer);
+    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationX).setDrawer(m_drawer);
+    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationY).setDrawer(m_drawer);
+    axisCacheForOrientation(Q3DAbstractAxis::AxisOrientationZ).setDrawer(m_drawer);
 }
 
 void Abstract3DRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
@@ -247,51 +247,51 @@ void Abstract3DRenderer::updateZoomLevel(int newZoomLevel)
     m_cachedZoomLevel = newZoomLevel;
 }
 
-void Abstract3DRenderer::updateAxisType(QAbstractAxis::AxisOrientation orientation, QAbstractAxis::AxisType type)
+void Abstract3DRenderer::updateAxisType(Q3DAbstractAxis::AxisOrientation orientation, Q3DAbstractAxis::AxisType type)
 {
     axisCacheForOrientation(orientation).setType(type);
 }
 
-void Abstract3DRenderer::updateAxisTitle(QAbstractAxis::AxisOrientation orientation, const QString &title)
+void Abstract3DRenderer::updateAxisTitle(Q3DAbstractAxis::AxisOrientation orientation, const QString &title)
 {
     axisCacheForOrientation(orientation).setTitle(title);
 }
 
-void Abstract3DRenderer::updateAxisLabels(QAbstractAxis::AxisOrientation orientation, const QStringList &labels)
+void Abstract3DRenderer::updateAxisLabels(Q3DAbstractAxis::AxisOrientation orientation, const QStringList &labels)
 {
     axisCacheForOrientation(orientation).setLabels(labels);
 }
 
-void Abstract3DRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
+void Abstract3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
 {
     AxisRenderCache &cache = axisCacheForOrientation(orientation);
     cache.setMin(min);
     cache.setMax(max);
 }
 
-void Abstract3DRenderer::updateAxisSegmentCount(QAbstractAxis::AxisOrientation orientation, int count)
+void Abstract3DRenderer::updateAxisSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count)
 {
     axisCacheForOrientation(orientation).setSegmentCount(count);
 }
 
-void Abstract3DRenderer::updateAxisSubSegmentCount(QAbstractAxis::AxisOrientation orientation, int count)
+void Abstract3DRenderer::updateAxisSubSegmentCount(Q3DAbstractAxis::AxisOrientation orientation, int count)
 {
     axisCacheForOrientation(orientation).setSubSegmentCount(count);
 }
 
-void Abstract3DRenderer::updateAxisLabelFormat(QAbstractAxis::AxisOrientation orientation, const QString &format)
+void Abstract3DRenderer::updateAxisLabelFormat(Q3DAbstractAxis::AxisOrientation orientation, const QString &format)
 {
     axisCacheForOrientation(orientation).setLabelFormat(format);
 }
 
-AxisRenderCache &Abstract3DRenderer::axisCacheForOrientation(QAbstractAxis::AxisOrientation orientation)
+AxisRenderCache &Abstract3DRenderer::axisCacheForOrientation(Q3DAbstractAxis::AxisOrientation orientation)
 {
     switch (orientation) {
-    case QAbstractAxis::AxisOrientationX:
+    case Q3DAbstractAxis::AxisOrientationX:
         return m_axisCacheX;
-    case QAbstractAxis::AxisOrientationY:
+    case Q3DAbstractAxis::AxisOrientationY:
         return m_axisCacheY;
-    case QAbstractAxis::AxisOrientationZ:
+    case Q3DAbstractAxis::AxisOrientationZ:
         return m_axisCacheZ;
     default:
         qFatal(__FUNCTION__);
diff --git a/src/datavis3d/engine/abstract3drenderer_p.h b/src/datavis3d/engine/abstract3drenderer_p.h
index ec057298..0da11ff1 100644
--- a/src/datavis3d/engine/abstract3drenderer_p.h
+++ b/src/datavis3d/engine/abstract3drenderer_p.h
@@ -112,13 +112,13 @@ public:
     virtual void updateShadowQuality(QDataVis::ShadowQuality quality) = 0;
     virtual void initShaders(const QString &vertexShader, const QString &fragmentShader) = 0;
     virtual void initBackgroundShaders(const QString &vertexShader, const QString &fragmentShader) = 0;
-    virtual void updateAxisType(QAbstractAxis::AxisOrientation orientation, QAbstractAxis::AxisType type);
-    virtual void updateAxisTitle(QAbstractAxis::AxisOrientation orientation, const QString &title);
-    virtual void updateAxisLabels(QAbstractAxis::AxisOrientation orientation, const QStringList &labels);
-    virtual void updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max);
-    virtual void updateAxisSegmentCount(QAbstractAxis::AxisOrientation orientation, int count);
-    virtual void updateAxisSubSegmentCount(QAbstractAxis::AxisOrientation orientation, int count);
-    virtual void updateAxisLabelFormat(QAbstractAxis::AxisOrientation orientation, const QString &format);
+    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, qreal min, qreal 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);
 
 protected:
     Abstract3DRenderer(Abstract3DController *controller);
@@ -129,7 +129,7 @@ protected:
     virtual void handleResize();
     virtual void loadMeshFile() = 0;
 
-    AxisRenderCache &axisCacheForOrientation(QAbstractAxis::AxisOrientation orientation);
+    AxisRenderCache &axisCacheForOrientation(Q3DAbstractAxis::AxisOrientation orientation);
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/axisrendercache.cpp b/src/datavis3d/engine/axisrendercache.cpp
index 0ca92247..e35018b5 100644
--- a/src/datavis3d/engine/axisrendercache.cpp
+++ b/src/datavis3d/engine/axisrendercache.cpp
@@ -22,7 +22,7 @@
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 AxisRenderCache::AxisRenderCache()
-    : m_type(QAbstractAxis::AxisTypeNone),
+    : m_type(Q3DAbstractAxis::AxisTypeNone),
       m_min(0.0),
       m_max(10.0),
       m_segmentCount(5),
@@ -48,7 +48,7 @@ void AxisRenderCache::setDrawer(Drawer *drawer)
     }
 }
 
-void AxisRenderCache::setType(QAbstractAxis::AxisType type)
+void AxisRenderCache::setType(Q3DAbstractAxis::AxisType type)
 {
     m_type = type;
 
diff --git a/src/datavis3d/engine/axisrendercache_p.h b/src/datavis3d/engine/axisrendercache_p.h
index 561c04cc..876ec077 100644
--- a/src/datavis3d/engine/axisrendercache_p.h
+++ b/src/datavis3d/engine/axisrendercache_p.h
@@ -31,7 +31,7 @@
 
 #include "datavis3dglobal_p.h"
 #include "labelitem_p.h"
-#include "qabstractaxis_p.h"
+#include "q3dabstractaxis_p.h"
 #include "drawer_p.h"
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
@@ -45,8 +45,8 @@ public:
 
     void setDrawer(Drawer *drawer);
 
-    void setType(QAbstractAxis::AxisType type);
-    inline QAbstractAxis::AxisType type() const { return m_type; }
+    void setType(Q3DAbstractAxis::AxisType type);
+    inline Q3DAbstractAxis::AxisType type() const { return m_type; }
     void setTitle(const QString &title);
     inline const QString &title() { return m_title; }
     void setLabels(const QStringList &labels);
@@ -75,7 +75,7 @@ private:
     void updateSubSegmentStep();
 
     // Cached axis values
-    QAbstractAxis::AxisType m_type;
+    Q3DAbstractAxis::AxisType m_type;
     QString m_title;
     QStringList m_labels;
     qreal m_min;
diff --git a/src/datavis3d/engine/bars3dcontroller.cpp b/src/datavis3d/engine/bars3dcontroller.cpp
index b59d6bd1..e8b5fe30 100644
--- a/src/datavis3d/engine/bars3dcontroller.cpp
+++ b/src/datavis3d/engine/bars3dcontroller.cpp
@@ -19,9 +19,9 @@
 #include "bars3dcontroller_p.h"
 #include "bars3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "qabstractaxis_p.h"
-#include "qvalueaxis_p.h"
-#include "qcategoryaxis.h"
+#include "q3dabstractaxis_p.h"
+#include "q3dvalueaxis_p.h"
+#include "q3dcategoryaxis.h"
 #include "qbardataproxy_p.h"
 
 #include <QMatrix4x4>
@@ -378,7 +378,7 @@ void Bars3DController::handleSelectedBarPosChanged(const QPoint &position)
 }
 
 void Bars3DController::handleAxisAutoAdjustRangeChangedInOrientation(
-        QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+        Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -502,7 +502,7 @@ int Bars3DController::rowCount()
 
 void Bars3DController::adjustValueAxisRange()
 {
-    QValueAxis *valueAxis = static_cast<QValueAxis *>(m_axisY);
+    Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
     if (valueAxis && valueAxis->isAutoAdjustRange() && m_data) {
         QPair<GLfloat, GLfloat> limits =
                 static_cast<QBarDataProxy *>(m_data)->dptr()->limitValues(0, m_rowCount,
@@ -520,11 +520,11 @@ void Bars3DController::adjustValueAxisRange()
     }
 }
 
-QAbstractAxis *Bars3DController::createDefaultAxis(QAbstractAxis::AxisOrientation orientation)
+Q3DAbstractAxis *Bars3DController::createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation)
 {
-    QAbstractAxis *defaultAxis = 0;
+    Q3DAbstractAxis *defaultAxis = 0;
 
-    if (orientation == QAbstractAxis::AxisOrientationY)
+    if (orientation == Q3DAbstractAxis::AxisOrientationY)
         defaultAxis = createDefaultValueAxis();
     else
         defaultAxis = createDefaultCategoryAxis();
diff --git a/src/datavis3d/engine/bars3dcontroller_p.h b/src/datavis3d/engine/bars3dcontroller_p.h
index d263c936..fff153cf 100644
--- a/src/datavis3d/engine/bars3dcontroller_p.h
+++ b/src/datavis3d/engine/bars3dcontroller_p.h
@@ -130,7 +130,7 @@ public:
 
     virtual void setActiveDataProxy(QAbstractDataProxy *proxy);
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
 
     static QPoint noSelectionPoint();
 
@@ -148,7 +148,7 @@ signals:
     void selectedBarPosChanged(QPoint position);
 
 protected:
-    virtual QAbstractAxis *createDefaultAxis(QAbstractAxis::AxisOrientation orientation);
+    virtual Q3DAbstractAxis *createDefaultAxis(Q3DAbstractAxis::AxisOrientation orientation);
 
 private:
     void adjustValueAxisRange();
diff --git a/src/datavis3d/engine/bars3drenderer.cpp b/src/datavis3d/engine/bars3drenderer.cpp
index 0dd182c4..50181f25 100644
--- a/src/datavis3d/engine/bars3drenderer.cpp
+++ b/src/datavis3d/engine/bars3drenderer.cpp
@@ -1451,7 +1451,7 @@ void Bars3DRenderer::updateBarSpecs(GLfloat thicknessRatio, QSizeF spacing, bool
     calculateSceneScalingFactors();
 }
 
-void Bars3DRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
+void Bars3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
 {
     Abstract3DRenderer::updateAxisRange(orientation, min, max);
     calculateHeightAdjustment();
diff --git a/src/datavis3d/engine/bars3drenderer_p.h b/src/datavis3d/engine/bars3drenderer_p.h
index cbfaa403..777e22ee 100644
--- a/src/datavis3d/engine/bars3drenderer_p.h
+++ b/src/datavis3d/engine/bars3drenderer_p.h
@@ -130,7 +130,7 @@ public slots:
     void updateSelectedBarPos(QPoint position);
 
     // Overloaded from abstract renderer
-    virtual void updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max);
+    virtual void updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, qreal min, qreal max);
 
 signals:
     void selectedBarPosChanged(QPoint position);
diff --git a/src/datavis3d/engine/q3dbars.cpp b/src/datavis3d/engine/q3dbars.cpp
index 374c256b..01731b40 100644
--- a/src/datavis3d/engine/q3dbars.cpp
+++ b/src/datavis3d/engine/q3dbars.cpp
@@ -19,8 +19,8 @@
 #include "q3dbars.h"
 #include "q3dbars_p.h"
 #include "bars3dcontroller_p.h"
-#include "qvalueaxis.h"
-#include "qcategoryaxis.h"
+#include "q3dvalueaxis.h"
+#include "q3dcategoryaxis.h"
 #include "qbardataproxy.h"
 
 #include <QMouseEvent>
@@ -423,7 +423,7 @@ QDataVis::ShadowQuality Q3DBars::shadowQuality() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setRowAxis(QCategoryAxis *axis)
+void Q3DBars::setRowAxis(Q3DCategoryAxis *axis)
 {
     d_ptr->m_shared->setAxisX(axis);
 }
@@ -431,9 +431,9 @@ void Q3DBars::setRowAxis(QCategoryAxis *axis)
 /*!
  * \return category axis for rows.
  */
-QCategoryAxis *Q3DBars::rowAxis() const
+Q3DCategoryAxis *Q3DBars::rowAxis() const
 {
-    return static_cast<QCategoryAxis *>(d_ptr->m_shared->axisX());
+    return static_cast<Q3DCategoryAxis *>(d_ptr->m_shared->axisX());
 }
 
 /*!
@@ -445,7 +445,7 @@ QCategoryAxis *Q3DBars::rowAxis() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setColumnAxis(QCategoryAxis *axis)
+void Q3DBars::setColumnAxis(Q3DCategoryAxis *axis)
 {
     d_ptr->m_shared->setAxisZ(axis);
 }
@@ -453,9 +453,9 @@ void Q3DBars::setColumnAxis(QCategoryAxis *axis)
 /*!
  * \return category axis for columns.
  */
-QCategoryAxis *Q3DBars::columnAxis() const
+Q3DCategoryAxis *Q3DBars::columnAxis() const
 {
-    return static_cast<QCategoryAxis *>(d_ptr->m_shared->axisZ());
+    return static_cast<Q3DCategoryAxis *>(d_ptr->m_shared->axisZ());
 }
 
 /*!
@@ -468,7 +468,7 @@ QCategoryAxis *Q3DBars::columnAxis() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DBars::setValueAxis(QValueAxis *axis)
+void Q3DBars::setValueAxis(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisY(axis);
 }
@@ -476,9 +476,9 @@ void Q3DBars::setValueAxis(QValueAxis *axis)
 /*!
  * \return used value axis (Y-axis).
  */
-QValueAxis *Q3DBars::valueAxis() const
+Q3DValueAxis *Q3DBars::valueAxis() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisY());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisY());
 }
 
 /*!
@@ -488,7 +488,7 @@ QValueAxis *Q3DBars::valueAxis() const
  *
  * \sa releaseAxis(), setValueAxis(), setRowAxis(), setColumnAxis()
  */
-void Q3DBars::addAxis(QAbstractAxis *axis)
+void Q3DBars::addAxis(Q3DAbstractAxis *axis)
 {
     d_ptr->m_shared->addAxis(axis);
 }
@@ -501,7 +501,7 @@ void Q3DBars::addAxis(QAbstractAxis *axis)
  *
  * \sa addAxis(), setValueAxis(), setRowAxis(), setColumnAxis()
  */
-void Q3DBars::releaseAxis(QAbstractAxis *axis)
+void Q3DBars::releaseAxis(Q3DAbstractAxis *axis)
 {
     d_ptr->m_shared->releaseAxis(axis);
 }
@@ -511,7 +511,7 @@ void Q3DBars::releaseAxis(QAbstractAxis *axis)
  *
  * \sa addAxis()
  */
-QList<QAbstractAxis *> Q3DBars::axes() const
+QList<Q3DAbstractAxis *> Q3DBars::axes() const
 {
     return d_ptr->m_shared->axes();
 }
diff --git a/src/datavis3d/engine/q3dbars.h b/src/datavis3d/engine/q3dbars.h
index 1792581e..095e7cdc 100644
--- a/src/datavis3d/engine/q3dbars.h
+++ b/src/datavis3d/engine/q3dbars.h
@@ -26,9 +26,9 @@
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 class Q3DBarsPrivate;
-class QAbstractAxis;
-class QCategoryAxis;
-class QValueAxis;
+class Q3DAbstractAxis;
+class Q3DCategoryAxis;
+class Q3DValueAxis;
 class QBarDataProxy;
 
 class QT_DATAVIS3D_EXPORT Q3DBars : public Q3DWindow
@@ -94,15 +94,15 @@ public:
     void setShadowQuality(QDataVis::ShadowQuality quality);
     QDataVis::ShadowQuality shadowQuality() const;
 
-    void setRowAxis(QCategoryAxis *axis);
-    QCategoryAxis *rowAxis() const;
-    void setColumnAxis(QCategoryAxis *axis);
-    QCategoryAxis *columnAxis() const;
-    void setValueAxis(QValueAxis *axis);
-    QValueAxis *valueAxis() const;
-    void addAxis(QAbstractAxis *axis);
-    void releaseAxis(QAbstractAxis *axis);
-    QList<QAbstractAxis *> axes() const;
+    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 setActiveDataProxy(QBarDataProxy *proxy);
     QBarDataProxy *activeDataProxy() const;
diff --git a/src/datavis3d/engine/q3dscatter.cpp b/src/datavis3d/engine/q3dscatter.cpp
index e18a7cd2..0316243e 100644
--- a/src/datavis3d/engine/q3dscatter.cpp
+++ b/src/datavis3d/engine/q3dscatter.cpp
@@ -19,7 +19,7 @@
 #include "q3dscatter.h"
 #include "q3dscatter_p.h"
 #include "scatter3dcontroller_p.h"
-#include "qvalueaxis.h"
+#include "q3dvalueaxis.h"
 #include "qscatterdataproxy.h"
 
 #include <QMouseEvent>
@@ -385,7 +385,7 @@ QDataVis::ShadowQuality Q3DScatter::shadowQuality() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisX(QValueAxis *axis)
+void Q3DScatter::setAxisX(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisX(axis);
 }
@@ -393,9 +393,9 @@ void Q3DScatter::setAxisX(QValueAxis *axis)
 /*!
  * \return used X-axis.
  */
-QValueAxis *Q3DScatter::axisX() const
+Q3DValueAxis *Q3DScatter::axisX() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisX());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisX());
 }
 
 /*!
@@ -408,7 +408,7 @@ QValueAxis *Q3DScatter::axisX() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisY(QValueAxis *axis)
+void Q3DScatter::setAxisY(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisY(axis);
 }
@@ -416,9 +416,9 @@ void Q3DScatter::setAxisY(QValueAxis *axis)
 /*!
  * \return used Y-axis.
  */
-QValueAxis *Q3DScatter::axisY() const
+Q3DValueAxis *Q3DScatter::axisY() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisY());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisY());
 }
 
 /*!
@@ -431,7 +431,7 @@ QValueAxis *Q3DScatter::axisY() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DScatter::setAxisZ(QValueAxis *axis)
+void Q3DScatter::setAxisZ(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisZ(axis);
 }
@@ -439,9 +439,9 @@ void Q3DScatter::setAxisZ(QValueAxis *axis)
 /*!
  * \return used Z-axis.
  */
-QValueAxis *Q3DScatter::axisZ() const
+Q3DValueAxis *Q3DScatter::axisZ() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisZ());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisZ());
 }
 
 /*!
@@ -451,7 +451,7 @@ QValueAxis *Q3DScatter::axisZ() const
  *
  * \sa releaseAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DScatter::addAxis(QValueAxis *axis)
+void Q3DScatter::addAxis(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->addAxis(axis);
 }
@@ -464,7 +464,7 @@ void Q3DScatter::addAxis(QValueAxis *axis)
  *
  * \sa addAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DScatter::releaseAxis(QValueAxis *axis)
+void Q3DScatter::releaseAxis(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->releaseAxis(axis);
 }
@@ -474,12 +474,12 @@ void Q3DScatter::releaseAxis(QValueAxis *axis)
  *
  * \sa addAxis()
  */
-QList<QValueAxis *> Q3DScatter::axes() const
+QList<Q3DValueAxis *> Q3DScatter::axes() const
 {
-    QList<QAbstractAxis *> abstractAxes = d_ptr->m_shared->axes();
-    QList<QValueAxis *> retList;
-    foreach (QAbstractAxis *axis, abstractAxes)
-        retList.append(static_cast<QValueAxis *>(axis));
+    QList<Q3DAbstractAxis *> abstractAxes = d_ptr->m_shared->axes();
+    QList<Q3DValueAxis *> retList;
+    foreach (Q3DAbstractAxis *axis, abstractAxes)
+        retList.append(static_cast<Q3DValueAxis *>(axis));
 
     return retList;
 }
diff --git a/src/datavis3d/engine/q3dscatter.h b/src/datavis3d/engine/q3dscatter.h
index 79169545..ea8fa681 100644
--- a/src/datavis3d/engine/q3dscatter.h
+++ b/src/datavis3d/engine/q3dscatter.h
@@ -27,8 +27,8 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
 
 class Q3DScatterPrivate;
 class LabelItem;
-class QValueAxis;
-class QCategoryAxis;
+class Q3DValueAxis;
+class Q3DCategoryAxis;
 class QScatterDataProxy;
 
 class QT_DATAVIS3D_EXPORT Q3DScatter : public Q3DWindow
@@ -86,15 +86,15 @@ public:
     void setShadowQuality(QDataVis::ShadowQuality quality);
     QDataVis::ShadowQuality shadowQuality() const;
 
-    void setAxisX(QValueAxis *axis);
-    QValueAxis *axisX() const;
-    void setAxisY(QValueAxis *axis);
-    QValueAxis *axisY() const;
-    void setAxisZ(QValueAxis *axis);
-    QValueAxis *axisZ() const;
-    void addAxis(QValueAxis *axis);
-    void releaseAxis(QValueAxis *axis);
-    QList<QValueAxis *> axes() const;
+    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 setActiveDataProxy(QScatterDataProxy *proxy);
     QScatterDataProxy *activeDataProxy() const;
diff --git a/src/datavis3d/engine/q3dsurface.cpp b/src/datavis3d/engine/q3dsurface.cpp
index 19b5cc54..aee3ecf2 100644
--- a/src/datavis3d/engine/q3dsurface.cpp
+++ b/src/datavis3d/engine/q3dsurface.cpp
@@ -18,7 +18,7 @@
 
 #include "q3dsurface.h"
 #include "q3dsurface_p.h"
-#include "qvalueaxis.h"
+#include "q3dvalueaxis.h"
 
 #include <QMouseEvent>
 
@@ -166,7 +166,7 @@ void Q3DSurface::setSegmentCount(int segmentCount, qreal step, qreal minimum)
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisX(QValueAxis *axis)
+void Q3DSurface::setAxisX(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisX(axis);
 }
@@ -174,9 +174,9 @@ void Q3DSurface::setAxisX(QValueAxis *axis)
 /*!
  * \return used X-axis.
  */
-QValueAxis *Q3DSurface::axisX() const
+Q3DValueAxis *Q3DSurface::axisX() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisX());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisX());
 }
 
 /*!
@@ -189,7 +189,7 @@ QValueAxis *Q3DSurface::axisX() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisY(QValueAxis *axis)
+void Q3DSurface::setAxisY(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisY(axis);
 }
@@ -197,9 +197,9 @@ void Q3DSurface::setAxisY(QValueAxis *axis)
 /*!
  * \return used Y-axis.
  */
-QValueAxis *Q3DSurface::axisY() const
+Q3DValueAxis *Q3DSurface::axisY() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisY());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisY());
 }
 
 /*!
@@ -212,7 +212,7 @@ QValueAxis *Q3DSurface::axisY() const
  *
  * \sa addAxis(), releaseAxis()
  */
-void Q3DSurface::setAxisZ(QValueAxis *axis)
+void Q3DSurface::setAxisZ(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->setAxisZ(axis);
 }
@@ -220,9 +220,9 @@ void Q3DSurface::setAxisZ(QValueAxis *axis)
 /*!
  * \return used Z-axis.
  */
-QValueAxis *Q3DSurface::axisZ() const
+Q3DValueAxis *Q3DSurface::axisZ() const
 {
-    return static_cast<QValueAxis *>(d_ptr->m_shared->axisZ());
+    return static_cast<Q3DValueAxis *>(d_ptr->m_shared->axisZ());
 }
 
 /*!
@@ -232,7 +232,7 @@ QValueAxis *Q3DSurface::axisZ() const
  *
  * \sa releaseAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DSurface::addAxis(QValueAxis *axis)
+void Q3DSurface::addAxis(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->addAxis(axis);
 }
@@ -245,7 +245,7 @@ void Q3DSurface::addAxis(QValueAxis *axis)
  *
  * \sa addAxis(), setAxisX(), setAxisY(), setAxisZ()
  */
-void Q3DSurface::releaseAxis(QValueAxis *axis)
+void Q3DSurface::releaseAxis(Q3DValueAxis *axis)
 {
     d_ptr->m_shared->releaseAxis(axis);
 }
@@ -255,12 +255,12 @@ void Q3DSurface::releaseAxis(QValueAxis *axis)
  *
  * \sa addAxis()
  */
-QList<QValueAxis *> Q3DSurface::axes() const
+QList<Q3DValueAxis *> Q3DSurface::axes() const
 {
-    QList<QAbstractAxis *> abstractAxes = d_ptr->m_shared->axes();
-    QList<QValueAxis *> retList;
-    foreach (QAbstractAxis *axis, abstractAxes)
-        retList.append(static_cast<QValueAxis *>(axis));
+    QList<Q3DAbstractAxis *> abstractAxes = d_ptr->m_shared->axes();
+    QList<Q3DValueAxis *> retList;
+    foreach (Q3DAbstractAxis *axis, abstractAxes)
+        retList.append(static_cast<Q3DValueAxis *>(axis));
 
     return retList;
 }
diff --git a/src/datavis3d/engine/q3dsurface.h b/src/datavis3d/engine/q3dsurface.h
index c46a3710..9492bfe4 100644
--- a/src/datavis3d/engine/q3dsurface.h
+++ b/src/datavis3d/engine/q3dsurface.h
@@ -25,7 +25,7 @@
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 class Q3DSurfacePrivate;
-class QValueAxis;
+class Q3DValueAxis;
 
 class QT_DATAVIS3D_EXPORT Q3DSurface : public Q3DWindow
 {
@@ -58,15 +58,15 @@ public:
     void setGradientColorAt(qreal pos, const QColor &color);
 
     // Axes
-    void setAxisX(QValueAxis *axis);
-    QValueAxis *axisX() const;
-    void setAxisY(QValueAxis *axis);
-    QValueAxis *axisY() const;
-    void setAxisZ(QValueAxis *axis);
-    QValueAxis *axisZ() const;
-    void addAxis(QValueAxis *axis);
-    void releaseAxis(QValueAxis *axis);
-    QList<QValueAxis *> axes() const;
+    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;
 
     // TODO: Remove when axes handling in use
     void setSegmentCount(int segmentCount, qreal step, qreal minimum = 0.0f);
diff --git a/src/datavis3d/engine/scatter3dcontroller.cpp b/src/datavis3d/engine/scatter3dcontroller.cpp
index 93070014..67c10f2b 100644
--- a/src/datavis3d/engine/scatter3dcontroller.cpp
+++ b/src/datavis3d/engine/scatter3dcontroller.cpp
@@ -19,8 +19,8 @@
 #include "scatter3dcontroller_p.h"
 #include "scatter3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "qabstractaxis_p.h"
-#include "qvalueaxis_p.h"
+#include "q3dabstractaxis_p.h"
+#include "q3dvalueaxis_p.h"
 #include "qscatterdataproxy_p.h"
 
 #include <QMatrix4x4>
@@ -330,7 +330,7 @@ void Scatter3DController::handleSelectedItemIndexChanged(int index)
 }
 
 void Scatter3DController::handleAxisAutoAdjustRangeChangedInOrientation(
-        QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+        Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -394,7 +394,7 @@ void Scatter3DController::adjustValueAxisRange()
 {
     if (m_data) {
         QVector3D limits = static_cast<QScatterDataProxy *>(m_data)->dptr()->limitValues();
-        QValueAxis *valueAxis = static_cast<QValueAxis *>(m_axisX);
+        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisX);
         if (valueAxis && valueAxis->isAutoAdjustRange()) {
             if (limits.x() > 0)
                 valueAxis->dptr()->setRange(-limits.x(), limits.x());
@@ -402,7 +402,7 @@ void Scatter3DController::adjustValueAxisRange()
                 valueAxis->dptr()->setRange(-1.0, 1.0); // Only zero value values in data set, set range to default.
         }
 
-        valueAxis = static_cast<QValueAxis *>(m_axisY);
+        valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
         if (valueAxis && valueAxis->isAutoAdjustRange()) {
             if (limits.y() > 0)
                 valueAxis->dptr()->setRange(-limits.y(), limits.y());
@@ -410,7 +410,7 @@ void Scatter3DController::adjustValueAxisRange()
                 valueAxis->dptr()->setRange(-1.0, 1.0); // Only zero value values in data set, set range to default.
         }
 
-        valueAxis = static_cast<QValueAxis *>(m_axisZ);
+        valueAxis = static_cast<Q3DValueAxis *>(m_axisZ);
         if (valueAxis && valueAxis->isAutoAdjustRange()) {
             if (limits.z() > 0)
                 valueAxis->dptr()->setRange(-limits.z(), limits.z());
diff --git a/src/datavis3d/engine/scatter3dcontroller_p.h b/src/datavis3d/engine/scatter3dcontroller_p.h
index 97fdeb4c..fd7d82ad 100644
--- a/src/datavis3d/engine/scatter3dcontroller_p.h
+++ b/src/datavis3d/engine/scatter3dcontroller_p.h
@@ -104,7 +104,7 @@ public:
 
     void synchDataToRenderer();
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
 
 public slots:
     void handleArrayReset();
diff --git a/src/datavis3d/engine/scatter3drenderer.cpp b/src/datavis3d/engine/scatter3drenderer.cpp
index 7849a75f..4a328307 100644
--- a/src/datavis3d/engine/scatter3drenderer.cpp
+++ b/src/datavis3d/engine/scatter3drenderer.cpp
@@ -1453,7 +1453,7 @@ void Scatter3DRenderer::updateTextures()
     m_updateLabels = true;
 }
 
-void Scatter3DRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation,
+void Scatter3DRenderer::updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation,
                                         qreal min, qreal max)
 {
     Abstract3DRenderer::updateAxisRange(orientation, min, max);
diff --git a/src/datavis3d/engine/scatter3drenderer_p.h b/src/datavis3d/engine/scatter3drenderer_p.h
index 50518a27..18752d59 100644
--- a/src/datavis3d/engine/scatter3drenderer_p.h
+++ b/src/datavis3d/engine/scatter3drenderer_p.h
@@ -45,7 +45,7 @@ class ShaderHelper;
 class ObjectHelper;
 class LabelItem;
 class CameraHelper;
-class QAbstractAxisPrivate;
+class Q3DAbstractAxisPrivate;
 
 class QT_DATAVIS3D_EXPORT Scatter3DRenderer : public Abstract3DRenderer
 {
@@ -137,7 +137,7 @@ public slots:
     void updateBackgroundEnabled(bool enable);
 
     // Overloaded from abstract renderer
-    virtual void updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max);
+    virtual void updateAxisRange(Q3DAbstractAxis::AxisOrientation orientation, qreal min, qreal max);
 
     void updateSelectedItemIndex(int index);
 
diff --git a/src/datavis3d/engine/surface3dcontroller.cpp b/src/datavis3d/engine/surface3dcontroller.cpp
index ae383384..90e23f07 100644
--- a/src/datavis3d/engine/surface3dcontroller.cpp
+++ b/src/datavis3d/engine/surface3dcontroller.cpp
@@ -19,9 +19,9 @@
 #include "surface3dcontroller_p.h"
 #include "surface3drenderer_p.h"
 #include "camerahelper_p.h"
-#include "qabstractaxis_p.h"
-#include "qvalueaxis_p.h"
-#include "qcategoryaxis.h"
+#include "q3dabstractaxis_p.h"
+#include "q3dvalueaxis_p.h"
+#include "q3dcategoryaxis.h"
 
 #include <QMatrix4x4>
 #include <QMouseEvent>
@@ -72,7 +72,7 @@ void Surface3DController::synchDataToRenderer()
     // Notify changes to renderer
 }
 
-void Surface3DController::handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+void Surface3DController::handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
diff --git a/src/datavis3d/engine/surface3dcontroller_p.h b/src/datavis3d/engine/surface3dcontroller_p.h
index b120f36e..d9f69f28 100644
--- a/src/datavis3d/engine/surface3dcontroller_p.h
+++ b/src/datavis3d/engine/surface3dcontroller_p.h
@@ -97,7 +97,7 @@ public:
     void mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos);
     void wheelEvent(QWheelEvent *event);
 
-    virtual void handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust);
+    virtual void handleAxisAutoAdjustRangeChangedInOrientation(Q3DAbstractAxis::AxisOrientation orientation, bool autoAdjust);
 
 signals:
     void smoothStatusChanged(bool enable);