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>

42 files changed, 452 insertions, 445 deletions

diff --git a/src/datavis3d/axis/axis.pri b/src/datavis3d/axis/axis.pri
index 7d5a1c6f..4e96618b 100644
--- a/src/datavis3d/axis/axis.pri
+++ b/src/datavis3d/axis/axis.pri
@@ -1,12 +1,12 @@
 HEADERS += \
-    $$PWD/qabstractaxis.h \
-    $$PWD/qabstractaxis_p.h \
-    $$PWD/qvalueaxis.h \
-    $$PWD/qvalueaxis_p.h \
-    $$PWD/qcategoryaxis.h \
-    $$PWD/qcategoryaxis_p.h
+    $$PWD/q3dabstractaxis.h \
+    $$PWD/q3dabstractaxis_p.h \
+    $$PWD/q3dvalueaxis.h \
+    $$PWD/q3dvalueaxis_p.h \
+    $$PWD/q3dcategoryaxis.h \
+    $$PWD/q3dcategoryaxis_p.h
 
 SOURCES += \
-    $$PWD/qabstractaxis.cpp \
-    $$PWD/qvalueaxis.cpp \
-    $$PWD/qcategoryaxis.cpp
+    $$PWD/q3dabstractaxis.cpp \
+    $$PWD/q3dvalueaxis.cpp \
+    $$PWD/q3dcategoryaxis.cpp
diff --git a/src/datavis3d/axis/qabstractaxis.cpp b/src/datavis3d/axis/q3dabstractaxis.cpp
index 0b233903..215351b8 100644
--- a/src/datavis3d/axis/qabstractaxis.cpp
+++ b/src/datavis3d/axis/q3dabstractaxis.cpp
@@ -16,24 +16,24 @@
 **
 ****************************************************************************/
 
-#include "qabstractaxis.h"
-#include "qabstractaxis_p.h"
+#include "q3dabstractaxis.h"
+#include "q3dabstractaxis_p.h"
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 /*!
- * \class QAbstractAxis
+ * \class Q3DAbstractAxis
  * \inmodule QtDataVis3D
- * \brief QAbstractAxis is base class for axes of a graph.
+ * \brief Q3DAbstractAxis is base class for axes of a graph.
  * \since 1.0.0
  *
  * You should not need to use this class directly, but one of its subclasses instead.
  *
- * \sa QCategoryAxis, QValueAxis
+ * \sa Q3DCategoryAxis, Q3DValueAxis
  */
 
 /*!
- * \enum QAbstractAxis::AxisOrientation
+ * \enum Q3DAbstractAxis::AxisOrientation
  *
  * The orientation of the axis object.
  *
@@ -44,7 +44,7 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
  */
 
 /*!
- * \enum QAbstractAxis::AxisType
+ * \enum Q3DAbstractAxis::AxisType
  *
  * The type of the axis object.
  *
@@ -56,61 +56,61 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
 /*!
  * \internal
  */
-QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate *d, QObject *parent) :
+Q3DAbstractAxis::Q3DAbstractAxis(Q3DAbstractAxisPrivate *d, QObject *parent) :
     QObject(parent),
     d_ptr(d)
 {
 }
 
 /*!
- * Destroys QAbstractAxis.
+ * Destroys Q3DAbstractAxis.
  */
-QAbstractAxis::~QAbstractAxis()
+Q3DAbstractAxis::~Q3DAbstractAxis()
 {
 }
 
 /*!
- * \property QAbstractAxis::title
+ * \property Q3DAbstractAxis::title
  *
  * Defines the title for the axis.
  */
-QString QAbstractAxis::title() const
+QString Q3DAbstractAxis::title() const
 {
     return d_ptr->m_title;
 }
 
 /*!
- * \property QAbstractAxis::labels
+ * \property Q3DAbstractAxis::labels
  *
  * Defines the labels for the axis.
  */
-QStringList QAbstractAxis::labels() const
+QStringList Q3DAbstractAxis::labels() const
 {
     d_ptr->updateLabels();
     return d_ptr->m_labels;
 }
 
 /*!
- * \property QAbstractAxis::orientation
+ * \property Q3DAbstractAxis::orientation
  *
- * Defines the orientation of the axis, one of \c QAbstractAxis::AxisOrientation.
+ * Defines the orientation of the axis, one of \c Q3DAbstractAxis::AxisOrientation.
  */
-QAbstractAxis::AxisOrientation QAbstractAxis::orientation() const
+Q3DAbstractAxis::AxisOrientation Q3DAbstractAxis::orientation() const
 {
     return d_ptr->m_orientation;
 }
 
 /*!
- * \property QAbstractAxis::type
+ * \property Q3DAbstractAxis::type
  *
- * Defines the type of the axis, one of \c QAbstractAxis::AxisType.
+ * Defines the type of the axis, one of \c Q3DAbstractAxis::AxisType.
  */
-QAbstractAxis::AxisType QAbstractAxis::type() const
+Q3DAbstractAxis::AxisType Q3DAbstractAxis::type() const
 {
     return d_ptr->m_type;
 }
 
-void QAbstractAxis::setTitle(QString title)
+void Q3DAbstractAxis::setTitle(QString title)
 {
     if (d_ptr->m_title != title) {
         d_ptr->m_title = title;
@@ -118,30 +118,30 @@ void QAbstractAxis::setTitle(QString title)
     }
 }
 
-// QAbstractAxisPrivate
+// Q3DAbstractAxisPrivate
 
-QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q, QAbstractAxis::AxisType type)
+Q3DAbstractAxisPrivate::Q3DAbstractAxisPrivate(Q3DAbstractAxis *q, Q3DAbstractAxis::AxisType type)
     : QObject(0),
       q_ptr(q),
-      m_orientation(QAbstractAxis::AxisOrientationNone),
+      m_orientation(Q3DAbstractAxis::AxisOrientationNone),
       m_type(type),
       m_isDefaultAxis(false)
 {
 }
 
-QAbstractAxisPrivate::~QAbstractAxisPrivate()
+Q3DAbstractAxisPrivate::~Q3DAbstractAxisPrivate()
 {
 }
 
-void QAbstractAxisPrivate::setOrientation(QAbstractAxis::AxisOrientation orientation)
+void Q3DAbstractAxisPrivate::setOrientation(Q3DAbstractAxis::AxisOrientation orientation)
 {
-    if (m_orientation == QAbstractAxis::AxisOrientationNone)
+    if (m_orientation == Q3DAbstractAxis::AxisOrientationNone)
         m_orientation = orientation;
     else
         Q_ASSERT("Attempted to reset axis orientation.");
 }
 
-void QAbstractAxisPrivate::updateLabels()
+void Q3DAbstractAxisPrivate::updateLabels()
 {
     // Default implementation does nothing
 }
diff --git a/src/datavis3d/axis/qabstractaxis.h b/src/datavis3d/axis/q3dabstractaxis.h
index 04c25af4..37bdb89e 100644
--- a/src/datavis3d/axis/qabstractaxis.h
+++ b/src/datavis3d/axis/q3dabstractaxis.h
@@ -16,8 +16,8 @@
 **
 ****************************************************************************/
 
-#ifndef QABSTRACTAXIS_H
-#define QABSTRACTAXIS_H
+#ifndef Q3DABSTRACTAXIS_H
+#define Q3DABSTRACTAXIS_H
 
 #include <QtDataVis3D/qdatavis3denums.h>
 #include <QObject>
@@ -27,9 +27,9 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QAbstractAxisPrivate;
+class Q3DAbstractAxisPrivate;
 
-class QT_DATAVIS3D_EXPORT QAbstractAxis : public QObject
+class QT_DATAVIS3D_EXPORT Q3DAbstractAxis : public QObject
 {
     Q_OBJECT
     Q_ENUMS(AxisOrientation)
@@ -55,10 +55,10 @@ public:
     };
 
 protected:
-    explicit QAbstractAxis(QAbstractAxisPrivate *d, QObject *parent = 0);
+    explicit Q3DAbstractAxis(Q3DAbstractAxisPrivate *d, QObject *parent = 0);
 
 public:
-    virtual ~QAbstractAxis();
+    virtual ~Q3DAbstractAxis();
 
     QString title() const;
     QStringList labels() const;
@@ -74,10 +74,10 @@ signals:
     void labelsChanged();
 
 protected:
-    QScopedPointer<QAbstractAxisPrivate> d_ptr;
+    QScopedPointer<Q3DAbstractAxisPrivate> d_ptr;
 
 private:
-    Q_DISABLE_COPY(QAbstractAxis)
+    Q_DISABLE_COPY(Q3DAbstractAxis)
 
     friend class Abstract3DController;
     friend class Bars3DController;
diff --git a/src/datavis3d/axis/qabstractaxis_p.h b/src/datavis3d/axis/q3dabstractaxis_p.h
index 6422868f..77f362db 100644
--- a/src/datavis3d/axis/qabstractaxis_p.h
+++ b/src/datavis3d/axis/q3dabstractaxis_p.h
@@ -27,22 +27,22 @@
 // We mean it.
 
 #include "datavis3dglobal_p.h"
-#include "qabstractaxis.h"
+#include "q3dabstractaxis.h"
 #include "abstract3dcontroller_p.h"
 
-#ifndef QABSTRACTAXIS_P_H
-#define QABSTRACTAXIS_P_H
+#ifndef Q3DABSTRACTAXIS_P_H
+#define Q3DABSTRACTAXIS_P_H
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QAbstractAxisPrivate : public QObject
+class Q3DAbstractAxisPrivate : public QObject
 {
     Q_OBJECT
 public:
-    QAbstractAxisPrivate(QAbstractAxis *q, QAbstractAxis::AxisType type);
-    virtual ~QAbstractAxisPrivate();
+    Q3DAbstractAxisPrivate(Q3DAbstractAxis *q, Q3DAbstractAxis::AxisType type);
+    virtual ~Q3DAbstractAxisPrivate();
 
-    void setOrientation(QAbstractAxis::AxisOrientation orientation);
+    void setOrientation(Q3DAbstractAxis::AxisOrientation orientation);
 
     inline bool isDefaultAxis() { return m_isDefaultAxis; }
     inline void setDefaultAxis(bool isDefault) { m_isDefaultAxis = isDefault; }
@@ -50,17 +50,17 @@ public:
 protected:
     virtual void updateLabels();
 
-    QAbstractAxis *q_ptr;
+    Q3DAbstractAxis *q_ptr;
 
     QString m_title;
     QStringList m_labels;
-    QAbstractAxis::AxisOrientation m_orientation;
-    QAbstractAxis::AxisType m_type;
+    Q3DAbstractAxis::AxisOrientation m_orientation;
+    Q3DAbstractAxis::AxisType m_type;
     bool m_isDefaultAxis;
 
-    friend class QAbstractAxis;
-    friend class QValueAxis;
-    friend class QCategoryAxis;
+    friend class Q3DAbstractAxis;
+    friend class Q3DValueAxis;
+    friend class Q3DCategoryAxis;
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/axis/qcategoryaxis.cpp b/src/datavis3d/axis/q3dcategoryaxis.cpp
index 8148ae0c..2090ad1c 100644
--- a/src/datavis3d/axis/qcategoryaxis.cpp
+++ b/src/datavis3d/axis/q3dcategoryaxis.cpp
@@ -16,18 +16,18 @@
 **
 ****************************************************************************/
 
-#include "qcategoryaxis.h"
-#include "qcategoryaxis_p.h"
+#include "q3dcategoryaxis.h"
+#include "q3dcategoryaxis_p.h"
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 /*!
- * \class QCategoryAxis
+ * \class Q3DCategoryAxis
  * \inmodule QtDataVis3D
- * \brief The QCategoryAxis class is used for manipulating an axis of a graph.
+ * \brief The Q3DCategoryAxis class is used for manipulating an axis of a graph.
  * \since 1.0.0
  *
- * QCategoryAxis provides an axis that can be given labels. The axis is divided into equal-sized
+ * Q3DCategoryAxis provides an axis that can be given labels. The axis is divided into equal-sized
  * categories based on \l {Q3DBars::setDataWindow()}{data window} size.
  *
  * Grid lines are drawn between categories, if visible. Labels are drawn to positions of categories
@@ -35,32 +35,32 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
  */
 
 /*!
- * Constructs QCategoryAxis with \a parent.
+ * Constructs Q3DCategoryAxis with \a parent.
  */
-QCategoryAxis::QCategoryAxis(QObject *parent) :
-    QAbstractAxis(new QCategoryAxisPrivate(this), parent)
+Q3DCategoryAxis::Q3DCategoryAxis(QObject *parent) :
+    Q3DAbstractAxis(new Q3DCategoryAxisPrivate(this), parent)
 {
 }
 
 /*!
- * Destroys QCategoryAxis.
+ * Destroys Q3DCategoryAxis.
  */
-QCategoryAxis::~QCategoryAxis()
+Q3DCategoryAxis::~Q3DCategoryAxis()
 {
 }
 
 /*!
- * \property QCategoryAxis::categoryLabels
+ * \property Q3DCategoryAxis::categoryLabels
  *
  * Defines labels for axis applied to categories. If there are fewer labels than categories, the
  * remaining ones do not have a label.
  */
-QStringList QCategoryAxis::categoryLabels() const
+QStringList Q3DCategoryAxis::categoryLabels() const
 {
     return labels();
 }
 
-void QCategoryAxis::setCategoryLabels(const QStringList &labels)
+void Q3DCategoryAxis::setCategoryLabels(const QStringList &labels)
 {
     if (d_ptr->m_labels != labels) {
         d_ptr->m_labels = labels;
@@ -71,17 +71,17 @@ void QCategoryAxis::setCategoryLabels(const QStringList &labels)
 /*!
  * \internal
  */
-QCategoryAxisPrivate *QCategoryAxis::dptr()
+Q3DCategoryAxisPrivate *Q3DCategoryAxis::dptr()
 {
-    return static_cast<QCategoryAxisPrivate *>(d_ptr.data());
+    return static_cast<Q3DCategoryAxisPrivate *>(d_ptr.data());
 }
 
-QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis *q)
-    : QAbstractAxisPrivate(q, QAbstractAxis::AxisTypeCategory)
+Q3DCategoryAxisPrivate::Q3DCategoryAxisPrivate(Q3DCategoryAxis *q)
+    : Q3DAbstractAxisPrivate(q, Q3DAbstractAxis::AxisTypeCategory)
 {
 }
 
-QCategoryAxisPrivate::~QCategoryAxisPrivate()
+Q3DCategoryAxisPrivate::~Q3DCategoryAxisPrivate()
 {
 }
 
diff --git a/src/datavis3d/axis/qcategoryaxis.h b/src/datavis3d/axis/q3dcategoryaxis.h
index ab82e8d6..15e9b6ed 100644
--- a/src/datavis3d/axis/qcategoryaxis.h
+++ b/src/datavis3d/axis/q3dcategoryaxis.h
@@ -16,16 +16,16 @@
 **
 ****************************************************************************/
 
-#ifndef QCATEGORYAXIS_H
-#define QCATEGORYAXIS_H
+#ifndef Q3DCATEGORYAXIS_H
+#define Q3DCATEGORYAXIS_H
 
-#include <QtDataVis3D/qabstractaxis.h>
+#include <QtDataVis3D/q3dabstractaxis.h>
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QCategoryAxisPrivate;
+class Q3DCategoryAxisPrivate;
 
-class QT_DATAVIS3D_EXPORT QCategoryAxis : public QAbstractAxis
+class QT_DATAVIS3D_EXPORT Q3DCategoryAxis : public Q3DAbstractAxis
 {
     Q_OBJECT
     // Note: categoryLabels actually reads/writes the labels property in abstract axis,
@@ -34,8 +34,8 @@ class QT_DATAVIS3D_EXPORT QCategoryAxis : public QAbstractAxis
     Q_PROPERTY(QStringList categoryLabels READ categoryLabels WRITE setCategoryLabels)
 
 public:
-    explicit QCategoryAxis(QObject *parent = 0);
-    virtual ~QCategoryAxis();
+    explicit Q3DCategoryAxis(QObject *parent = 0);
+    virtual ~Q3DCategoryAxis();
 
     QStringList categoryLabels() const;
 
@@ -43,11 +43,10 @@ public slots:
     void setCategoryLabels(const QStringList &labels);
 
 protected:
-    QCategoryAxisPrivate *dptr();
+    Q3DCategoryAxisPrivate *dptr();
 
 private:
-
-    Q_DISABLE_COPY(QCategoryAxis)
+    Q_DISABLE_COPY(Q3DCategoryAxis)
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/axis/qcategoryaxis_p.h b/src/datavis3d/axis/q3dcategoryaxis_p.h
index 3ca79c64..e2e9d574 100644
--- a/src/datavis3d/axis/qcategoryaxis_p.h
+++ b/src/datavis3d/axis/q3dcategoryaxis_p.h
@@ -26,8 +26,8 @@
 //
 // We mean it.
 
-#include "qcategoryaxis.h"
-#include "qabstractaxis_p.h"
+#include "q3dcategoryaxis.h"
+#include "q3dabstractaxis_p.h"
 #include "qbardataitem.h"
 
 #ifndef QCATEGORYAXIS_P_H
@@ -35,13 +35,13 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QCategoryAxisPrivate : public QAbstractAxisPrivate
+class Q3DCategoryAxisPrivate : public Q3DAbstractAxisPrivate
 {
     Q_OBJECT
 
 public:
-    QCategoryAxisPrivate(QCategoryAxis *q);
-    virtual ~QCategoryAxisPrivate();
+    Q3DCategoryAxisPrivate(Q3DCategoryAxis *q);
+    virtual ~Q3DCategoryAxisPrivate();
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/axis/qvalueaxis.cpp b/src/datavis3d/axis/q3dvalueaxis.cpp
index 9520cacd..50a0525c 100644
--- a/src/datavis3d/axis/qvalueaxis.cpp
+++ b/src/datavis3d/axis/q3dvalueaxis.cpp
@@ -16,19 +16,19 @@
 **
 ****************************************************************************/
 
-#include "qvalueaxis.h"
-#include "qvalueaxis_p.h"
+#include "q3dvalueaxis.h"
+#include "q3dvalueaxis_p.h"
 #include "utils_p.h"
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
 /*!
- * \class QValueAxis
+ * \class Q3DValueAxis
  * \inmodule QtDataVis3D
- * \brief The QValueAxis class is used for manipulating an axis of a graph.
+ * \brief The Q3DValueAxis class is used for manipulating an axis of a graph.
  * \since 1.0.0
  *
- * QValueAxis provides an axis that can be given a range of values and segment and subsegment
+ * Q3DValueAxis provides an axis that can be given a range of values and segment and subsegment
  * counts to divide the range into.
  *
  * Labels are drawn between each segment. Grid lines are drawn between each segment and each
@@ -37,17 +37,17 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
  */
 
 /*!
- * Constructs QValueAxis with the given \a parent.
+ * Constructs Q3DValueAxis with the given \a parent.
  */
-QValueAxis::QValueAxis(QObject *parent) :
-    QAbstractAxis(new QValueAxisPrivate(this), parent)
+Q3DValueAxis::Q3DValueAxis(QObject *parent) :
+    Q3DAbstractAxis(new Q3DValueAxisPrivate(this), parent)
 {
 }
 
 /*!
- * Destroys QValueAxis.
+ * Destroys Q3DValueAxis.
  */
-QValueAxis::~QValueAxis()
+Q3DValueAxis::~Q3DValueAxis()
 {
 }
 
@@ -55,50 +55,50 @@ QValueAxis::~QValueAxis()
  * Sets value range of the axis from \a min to \a max.
  * When setting the range, the max is adjusted if necessary, to ensure that the range remains valid.
  */
-void QValueAxis::setRange(qreal min, qreal max)
+void Q3DValueAxis::setRange(qreal min, qreal max)
 {
     dptr()->setRange(min, max);
     setAutoAdjustRange(false);
 }
 
 /*!
- * \property QValueAxis::min
+ * \property Q3DValueAxis::min
  *
  * Defines the minimum value on the axis.
  * When setting this property the max is adjusted if necessary, to ensure that the range remains
  * valid.
  */
-void QValueAxis::setMin(qreal min)
+void Q3DValueAxis::setMin(qreal min)
 {
     dptr()->setMin(min);
     setAutoAdjustRange(false);
 }
 
 /*!
- * \property QValueAxis::max
+ * \property Q3DValueAxis::max
  *
  * Defines the maximum value on the axis.
  * When setting this property the min is adjusted if necessary, to ensure that the range remains
  * valid.
  */
-void QValueAxis::setMax(qreal max)
+void Q3DValueAxis::setMax(qreal max)
 {
     dptr()->setMax(max);
     setAutoAdjustRange(false);
 }
 
-qreal QValueAxis::min() const
+qreal Q3DValueAxis::min() const
 {
     return dptrc()->m_min;
 }
 
-qreal QValueAxis::max() const
+qreal Q3DValueAxis::max() const
 {
     return dptrc()->m_max;
 }
 
 /*!
- * \property QValueAxis::segmentCount
+ * \property Q3DValueAxis::segmentCount
  *
  * Defines the number of segments on the axis. This indicates how many labels are drawn. The number
  * of grid lines to be drawn is calculated with formula: \c {segments * subsegments + 1}.
@@ -106,7 +106,7 @@ qreal QValueAxis::max() const
  *
  * \sa setSubSegmentCount()
  */
-void QValueAxis::setSegmentCount(int count)
+void Q3DValueAxis::setSegmentCount(int count)
 {
     if (count <= 0) {
         qWarning() << "Warning: Illegal segment count automatically adjusted to a legal one:"
@@ -120,13 +120,13 @@ void QValueAxis::setSegmentCount(int count)
     }
 }
 
-int QValueAxis::segmentCount() const
+int Q3DValueAxis::segmentCount() const
 {
     return dptrc()->m_segmentCount;
 }
 
 /*!
- * \property QValueAxis::subSegmentCount
+ * \property Q3DValueAxis::subSegmentCount
  *
  * Defines the number of subsegments inside each segment on the axis. Grid lines are drawn between
  * each subsegment, in addition to each segment.
@@ -134,7 +134,7 @@ int QValueAxis::segmentCount() const
  *
  * \sa setSegmentCount()
  **/
-void QValueAxis::setSubSegmentCount(int count)
+void Q3DValueAxis::setSubSegmentCount(int count)
 {
     if (count <= 0) {
         qWarning() << "Warning: Illegal subsegment count automatically adjusted to a legal one:"
@@ -147,20 +147,20 @@ void QValueAxis::setSubSegmentCount(int count)
     }
 }
 
-int QValueAxis::subSegmentCount() const
+int Q3DValueAxis::subSegmentCount() const
 {
     return dptrc()->m_subSegmentCount;
 }
 
 /*!
- * \property QValueAxis::autoAdjustRange
+ * \property Q3DValueAxis::autoAdjustRange
  *
  * Tells the axis to automatically calculate the range instead of setting range or adjusting min or
  * max property.
  *
  * \sa setRange(), setMin(), setMax()
  */
-void QValueAxis::setAutoAdjustRange(bool autoAdjust)
+void Q3DValueAxis::setAutoAdjustRange(bool autoAdjust)
 {
     if (dptr()->m_autoAdjust != autoAdjust) {
         dptr()->m_autoAdjust = autoAdjust;
@@ -168,13 +168,13 @@ void QValueAxis::setAutoAdjustRange(bool autoAdjust)
     }
 }
 
-bool QValueAxis::isAutoAdjustRange() const
+bool Q3DValueAxis::isAutoAdjustRange() const
 {
     return dptrc()->m_autoAdjust;
 }
 
 /*!
- * \property QValueAxis::labelFormat
+ * \property Q3DValueAxis::labelFormat
  *
  * Defines the label format to be used for the labels on this axis. Supported specifiers are:
  * \c {d, i, o, x, X, f, F, e, E, g, G, c}. See QString::sprintf() for additional details.
@@ -183,7 +183,7 @@ bool QValueAxis::isAutoAdjustRange() const
  *
  * \c {axis->setLabelFormat("%.2f mm");}
  */
-void QValueAxis::setLabelFormat(const QString &format)
+void Q3DValueAxis::setLabelFormat(const QString &format)
 {
     if (dptr()->m_labelFormat != format) {
         dptr()->m_labelFormat = format;
@@ -192,7 +192,7 @@ void QValueAxis::setLabelFormat(const QString &format)
     }
 }
 
-QString QValueAxis::labelFormat() const
+QString Q3DValueAxis::labelFormat() const
 {
     return dptrc()->m_labelFormat;
 }
@@ -200,21 +200,21 @@ QString QValueAxis::labelFormat() const
 /*!
  * \internal
  */
-QValueAxisPrivate *QValueAxis::dptr()
+Q3DValueAxisPrivate *Q3DValueAxis::dptr()
 {
-    return static_cast<QValueAxisPrivate *>(d_ptr.data());
+    return static_cast<Q3DValueAxisPrivate *>(d_ptr.data());
 }
 
 /*!
  * \internal
  */
-const QValueAxisPrivate *QValueAxis::dptrc() const
+const Q3DValueAxisPrivate *Q3DValueAxis::dptrc() const
 {
-    return static_cast<const QValueAxisPrivate *>(d_ptr.data());
+    return static_cast<const Q3DValueAxisPrivate *>(d_ptr.data());
 }
 
-QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
-    : QAbstractAxisPrivate(q, QAbstractAxis::AxisTypeValue),
+Q3DValueAxisPrivate::Q3DValueAxisPrivate(Q3DValueAxis *q)
+    : Q3DAbstractAxisPrivate(q, Q3DAbstractAxis::AxisTypeValue),
       m_min(0.0),
       m_max(10.0),
       m_segmentCount(5),
@@ -225,11 +225,11 @@ QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
 {
 }
 
-QValueAxisPrivate::~QValueAxisPrivate()
+Q3DValueAxisPrivate::~Q3DValueAxisPrivate()
 {
 }
 
-void QValueAxisPrivate::setRange(qreal min, qreal max)
+void Q3DValueAxisPrivate::setRange(qreal min, qreal max)
 {
     // If min >= max, we adjust ranges so that
     // m_max becomes (min + 1.0)
@@ -257,7 +257,7 @@ void QValueAxisPrivate::setRange(qreal min, qreal max)
     }
 }
 
-void QValueAxisPrivate::setMin(qreal min)
+void Q3DValueAxisPrivate::setMin(qreal min)
 {
     if (m_min != min) {
         if (min >= m_max) {
@@ -273,7 +273,7 @@ void QValueAxisPrivate::setMin(qreal min)
     }
 }
 
-void QValueAxisPrivate::setMax(qreal max)
+void Q3DValueAxisPrivate::setMax(qreal max)
 {
     if (m_max != max) {
         if (max <= m_min) {
@@ -289,13 +289,13 @@ void QValueAxisPrivate::setMax(qreal max)
     }
 }
 
-void QValueAxisPrivate::emitLabelsChanged()
+void Q3DValueAxisPrivate::emitLabelsChanged()
 {
     m_labelsDirty = true;
     emit q_ptr->labelsChanged();
 }
 
-void QValueAxisPrivate::updateLabels()
+void Q3DValueAxisPrivate::updateLabels()
 {
     if (!m_labelsDirty)
         return;
@@ -324,9 +324,9 @@ void QValueAxisPrivate::updateLabels()
         m_labels = newLabels;
 }
 
-QValueAxis *QValueAxisPrivate::qptr()
+Q3DValueAxis *Q3DValueAxisPrivate::qptr()
 {
-    return static_cast<QValueAxis *>(q_ptr);
+    return static_cast<Q3DValueAxis *>(q_ptr);
 }
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/axis/qvalueaxis.h b/src/datavis3d/axis/q3dvalueaxis.h
index 1d527feb..07e21a41 100644
--- a/src/datavis3d/axis/qvalueaxis.h
+++ b/src/datavis3d/axis/q3dvalueaxis.h
@@ -19,13 +19,13 @@
 #ifndef QVALUEAXIS_H
 #define QVALUEAXIS_H
 
-#include <QtDataVis3D/qabstractaxis.h>
+#include <QtDataVis3D/q3dabstractaxis.h>
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QValueAxisPrivate;
+class Q3DValueAxisPrivate;
 
-class QT_DATAVIS3D_EXPORT QValueAxis : public QAbstractAxis
+class QT_DATAVIS3D_EXPORT Q3DValueAxis : public Q3DAbstractAxis
 {
     Q_OBJECT
     Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY rangeChanged)
@@ -36,8 +36,8 @@ class QT_DATAVIS3D_EXPORT QValueAxis : public QAbstractAxis
     Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat NOTIFY labelFormatChanged)
 
 public:
-    explicit QValueAxis(QObject *parent = 0);
-    virtual ~QValueAxis();
+    explicit Q3DValueAxis(QObject *parent = 0);
+    virtual ~Q3DValueAxis();
 
     qreal min() const;
     qreal max() const;
@@ -63,11 +63,11 @@ signals:
     void labelFormatChanged(QString format);
 
 protected:
-    QValueAxisPrivate *dptr();
-    const QValueAxisPrivate *dptrc() const;
+    Q3DValueAxisPrivate *dptr();
+    const Q3DValueAxisPrivate *dptrc() const;
 
 private:
-    Q_DISABLE_COPY(QValueAxis)
+    Q_DISABLE_COPY(Q3DValueAxis)
     friend class Bars3DController;
     friend class Scatter3DController;
 };
diff --git a/src/datavis3d/axis/qvalueaxis_p.h b/src/datavis3d/axis/q3dvalueaxis_p.h
index 6d8cc362..823983aa 100644
--- a/src/datavis3d/axis/qvalueaxis_p.h
+++ b/src/datavis3d/axis/q3dvalueaxis_p.h
@@ -26,21 +26,21 @@
 //
 // We mean it.
 
-#include "qvalueaxis.h"
-#include "qabstractaxis_p.h"
+#include "q3dvalueaxis.h"
+#include "q3dabstractaxis_p.h"
 
 #ifndef QVALUEAXIS_P_H
 #define QVALUEAXIS_P_H
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class QValueAxisPrivate : public QAbstractAxisPrivate
+class Q3DValueAxisPrivate : public Q3DAbstractAxisPrivate
 {
     Q_OBJECT
 
 public:
-    QValueAxisPrivate(QValueAxis *q);
-    virtual ~QValueAxisPrivate();
+    Q3DValueAxisPrivate(Q3DValueAxis *q);
+    virtual ~Q3DValueAxisPrivate();
 
     void setRange(qreal min, qreal max);
     void setMin(qreal min);
@@ -59,9 +59,9 @@ protected:
     bool m_labelsDirty;
 
 private:
-    QValueAxis *qptr();
+    Q3DValueAxis *qptr();
 
-    friend class QValueAxis;
+    friend class Q3DValueAxis;
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/data/qbardataproxy.cpp b/src/datavis3d/data/qbardataproxy.cpp
index 50eafec5..c0ff2f7f 100644
--- a/src/datavis3d/data/qbardataproxy.cpp
+++ b/src/datavis3d/data/qbardataproxy.cpp
@@ -55,7 +55,7 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
  *     \li @colLabel      \li Label from column axis
  *   \row
  *     \li @valueLabel    \li Item value formatted using the same format the value axis attached to the graph uses,
- *                            see \l{QValueAxis::setLabelFormat()} for more information.
+ *                            see \l{Q3DValueAxis::setLabelFormat()} for more information.
  *   \row
  *     \li %<format spec> \li Item value in specified format.
  * \endtable
diff --git a/src/datavis3d/data/qitemmodelbardatamapping.cpp b/src/datavis3d/data/qitemmodelbardatamapping.cpp
index 8877f891..cefe5b5e 100644
--- a/src/datavis3d/data/qitemmodelbardatamapping.cpp
+++ b/src/datavis3d/data/qitemmodelbardatamapping.cpp
@@ -188,11 +188,19 @@ void QItemModelBarDataMapping::remap(const QString &rowRole,
     emit mappingChanged();
 }
 
+/*!
+ * /return index of the specified \a category in row categories list.
+ * If the category is not found, -1 is returned.
+ */
 int QItemModelBarDataMapping::rowCategoryIndex(const QString &category)
 {
     return dptr()->m_rowCategories.indexOf(category);
 }
 
+/*!
+ * /return index of the specified \a category in column categories list.
+ * If the category is not found, -1 is returned.
+ */
 int QItemModelBarDataMapping::columnCategoryIndex(const QString &category)
 {
     return dptr()->m_columnCategories.indexOf(category);
diff --git a/src/datavis3d/data/qscatterdataproxy.cpp b/src/datavis3d/data/qscatterdataproxy.cpp
index 39fb2470..16b14621 100644
--- a/src/datavis3d/data/qscatterdataproxy.cpp
+++ b/src/datavis3d/data/qscatterdataproxy.cpp
@@ -41,13 +41,13 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
  *     \li @zTitle    \li Title from Z axis
  *   \row
  *     \li @xLabel    \li Item value formatted using the same format the X axis attached to the graph uses,
- *                            see \l{QValueAxis::setLabelFormat()} for more information.
+ *                            see \l{Q3DValueAxis::setLabelFormat()} for more information.
  *   \row
  *     \li @yLabel    \li Item value formatted using the same format the Y axis attached to the graph uses,
- *                            see \l{QValueAxis::setLabelFormat()} for more information.
+ *                            see \l{Q3DValueAxis::setLabelFormat()} for more information.
  *   \row
  *     \li @zLabel    \li Item value formatted using the same format the Z axis attached to the graph uses,
- *                            see \l{QValueAxis::setLabelFormat()} for more information.
+ *                            see \l{Q3DValueAxis::setLabelFormat()} for more information.
  * \endtable
  *
  * For example:
diff --git a/src/datavis3d/doc/src/qtdatavis3d-index.qdoc b/src/datavis3d/doc/src/qtdatavis3d-index.qdoc
index b45e7cb6..d5bff9f8 100644
--- a/src/datavis3d/doc/src/qtdatavis3d-index.qdoc
+++ b/src/datavis3d/doc/src/qtdatavis3d-index.qdoc
@@ -54,7 +54,7 @@
         \li \l{Qt Quick 2 Scatter Example}
         \li \l{Rainfall Example}
         \li \l{Scatter Chart Example}
-        \li \l{Spectrum Example}
+        \li \l{Audiolevels Example}
         \li \l{Widget Example}
     \endlist
 */
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);
diff --git a/src/datavis3dqml2/datavis3dqml2_plugin.cpp b/src/datavis3dqml2/datavis3dqml2_plugin.cpp
index b4a34f85..48f39cf4 100644
--- a/src/datavis3dqml2/datavis3dqml2_plugin.cpp
+++ b/src/datavis3dqml2/datavis3dqml2_plugin.cpp
@@ -29,7 +29,7 @@ void Datavis3Dqml2Plugin::registerTypes(const char *uri)
                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
     qmlRegisterUncreatableType<QDataVis>(uri, 1, 0, "DataVis",
                                          QLatin1String("Trying to create uncreatable: DataVis."));
-    qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
+    qmlRegisterUncreatableType<Q3DAbstractAxis>(uri, 1, 0, "AbstractAxis3D",
                                               QLatin1String("Trying to create uncreatable: AbstractAxis."));
 
     qmlRegisterType<QItemModelBarDataMapping>(uri, 1, 0, "BarDataMapping");
@@ -38,8 +38,8 @@ void Datavis3Dqml2Plugin::registerTypes(const char *uri)
     qmlRegisterType<DeclarativeBars>(uri, 1, 0, "Bars3D");
     qmlRegisterType<DeclarativeScatter>(uri, 1, 0, "Scatter3D");
 
-    qmlRegisterType<QValueAxis>(uri, 1, 0, "ValueAxis");
-    qmlRegisterType<QCategoryAxis>(uri, 1, 0, "CategoryAxis");
+    qmlRegisterType<Q3DValueAxis>(uri, 1, 0, "ValueAxis3D");
+    qmlRegisterType<Q3DCategoryAxis>(uri, 1, 0, "CategoryAxis3D");
 }
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3dqml2/datavis3dqml2_plugin.h b/src/datavis3dqml2/datavis3dqml2_plugin.h
index aaa3add9..35bd8840 100644
--- a/src/datavis3dqml2/datavis3dqml2_plugin.h
+++ b/src/datavis3dqml2/datavis3dqml2_plugin.h
@@ -24,8 +24,8 @@
 #include "declarativescatter_p.h"
 #include "qitemmodelbardatamapping.h"
 #include "qitemmodelscatterdatamapping.h"
-#include "qvalueaxis.h"
-#include "qcategoryaxis.h"
+#include "q3dvalueaxis.h"
+#include "q3dcategoryaxis.h"
 
 #include <QQmlExtensionPlugin>
 
@@ -39,9 +39,9 @@ Q_DECLARE_METATYPE(QItemModelScatterDataMapping *)
 Q_DECLARE_METATYPE(const QAbstractItemModel *)
 Q_DECLARE_METATYPE(QDataVis *)
 
-Q_DECLARE_METATYPE(QAbstractAxis *)
-Q_DECLARE_METATYPE(QCategoryAxis *)
-Q_DECLARE_METATYPE(QValueAxis *)
+Q_DECLARE_METATYPE(Q3DAbstractAxis *)
+Q_DECLARE_METATYPE(Q3DCategoryAxis *)
+Q_DECLARE_METATYPE(Q3DValueAxis *)
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
diff --git a/src/datavis3dqml2/declarativebars.cpp b/src/datavis3dqml2/declarativebars.cpp
index 72141c42..f94487bc 100644
--- a/src/datavis3dqml2/declarativebars.cpp
+++ b/src/datavis3dqml2/declarativebars.cpp
@@ -19,7 +19,7 @@
 #include "declarativebars_p.h"
 #include "declarativebarsrenderer_p.h"
 #include "qitemmodelbardataproxy.h"
-#include "qvalueaxis.h"
+#include "q3dvalueaxis.h"
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
@@ -125,32 +125,32 @@ void DeclarativeBars::setMapping(QItemModelBarDataMapping *mapping)
     static_cast<QItemModelBarDataProxy *>(m_shared->activeDataProxy())->setActiveMapping(mapping);
 }
 
-QCategoryAxis *DeclarativeBars::rowAxis() const
+Q3DCategoryAxis *DeclarativeBars::rowAxis() const
 {
-    return static_cast<QCategoryAxis *>(m_shared->axisX());
+    return static_cast<Q3DCategoryAxis *>(m_shared->axisX());
 }
 
-void DeclarativeBars::setRowAxis(QCategoryAxis *axis)
+void DeclarativeBars::setRowAxis(Q3DCategoryAxis *axis)
 {
     m_shared->setAxisX(axis);
 }
 
-QValueAxis *DeclarativeBars::valueAxis() const
+Q3DValueAxis *DeclarativeBars::valueAxis() const
 {
-    return static_cast<QValueAxis *>(m_shared->axisY());
+    return static_cast<Q3DValueAxis *>(m_shared->axisY());
 }
 
-void DeclarativeBars::setValueAxis(QValueAxis *axis)
+void DeclarativeBars::setValueAxis(Q3DValueAxis *axis)
 {
     m_shared->setAxisY(axis);
 }
 
-QCategoryAxis *DeclarativeBars::columnAxis() const
+Q3DCategoryAxis *DeclarativeBars::columnAxis() const
 {
-    return static_cast<QCategoryAxis *>(m_shared->axisZ());
+    return static_cast<Q3DCategoryAxis *>(m_shared->axisZ());
 }
 
-void DeclarativeBars::setColumnAxis(QCategoryAxis *axis)
+void DeclarativeBars::setColumnAxis(Q3DCategoryAxis *axis)
 {
     m_shared->setAxisZ(axis);
 }
diff --git a/src/datavis3dqml2/declarativebars_p.h b/src/datavis3dqml2/declarativebars_p.h
index 4a2a74ad..283afdfb 100644
--- a/src/datavis3dqml2/declarativebars_p.h
+++ b/src/datavis3dqml2/declarativebars_p.h
@@ -33,8 +33,8 @@
 #include "bars3dcontroller_p.h"
 #include "declarativebars_p.h"
 #include "qitemmodelbardatamapping.h"
-#include "qvalueaxis.h"
-#include "qcategoryaxis.h"
+#include "q3dvalueaxis.h"
+#include "q3dcategoryaxis.h"
 
 #include <QAbstractItemModel>
 #include <QQuickItem>
@@ -48,9 +48,9 @@ class DeclarativeBars : public QQuickItem
     Q_OBJECT
     Q_PROPERTY(const QAbstractItemModel *data READ data WRITE setData)
     Q_PROPERTY(QItemModelBarDataMapping *mapping READ mapping WRITE setMapping)
-    Q_PROPERTY(QCategoryAxis *rowAxis READ rowAxis WRITE setRowAxis)
-    Q_PROPERTY(QValueAxis *valueAxis READ valueAxis WRITE setValueAxis)
-    Q_PROPERTY(QCategoryAxis *columnAxis READ columnAxis WRITE setColumnAxis)
+    Q_PROPERTY(Q3DCategoryAxis *rowAxis READ rowAxis WRITE setRowAxis)
+    Q_PROPERTY(Q3DValueAxis *valueAxis READ valueAxis WRITE setValueAxis)
+    Q_PROPERTY(Q3DCategoryAxis *columnAxis READ columnAxis WRITE setColumnAxis)
     Q_PROPERTY(QtDataVis3D::QDataVis::SelectionMode selectionMode READ selectionMode WRITE setSelectionMode)
     Q_PROPERTY(QtDataVis3D::QDataVis::LabelTransparency labelTransparency READ labelTransparency WRITE setLabelTransparency)
     Q_PROPERTY(QtDataVis3D::QDataVis::ShadowQuality shadowQuality READ shadowQuality WRITE setShadowQuality)
@@ -103,12 +103,12 @@ public:
     QItemModelBarDataMapping *mapping() const;
     void setMapping(QItemModelBarDataMapping *mapping);
 
-    QCategoryAxis *rowAxis() const;
-    void setRowAxis(QCategoryAxis *axis);
-    QValueAxis *valueAxis() const;
-    void setValueAxis(QValueAxis *axis);
-    QCategoryAxis *columnAxis() const;
-    void setColumnAxis(QCategoryAxis *axis);
+    Q3DCategoryAxis *rowAxis() const;
+    void setRowAxis(Q3DCategoryAxis *axis);
+    Q3DValueAxis *valueAxis() const;
+    void setValueAxis(Q3DValueAxis *axis);
+    Q3DCategoryAxis *columnAxis() const;
+    void setColumnAxis(Q3DCategoryAxis *axis);
 
     // Set bar thickness.
     void setBarThickness(qreal thicknessRatio);
diff --git a/src/datavis3dqml2/declarativescatter.cpp b/src/datavis3dqml2/declarativescatter.cpp
index 9bd568ce..c38dc9d0 100644
--- a/src/datavis3dqml2/declarativescatter.cpp
+++ b/src/datavis3dqml2/declarativescatter.cpp
@@ -120,32 +120,32 @@ QItemModelScatterDataMapping *DeclarativeScatter::mapping() const
     return static_cast<QItemModelScatterDataProxy *>(m_shared->activeDataProxy())->activeMapping();
 }
 
-QValueAxis *DeclarativeScatter::axisX() const
+Q3DValueAxis *DeclarativeScatter::axisX() const
 {
-    return static_cast<QValueAxis *>(m_shared->axisX());
+    return static_cast<Q3DValueAxis *>(m_shared->axisX());
 }
 
-void DeclarativeScatter::setAxisX(QValueAxis *axis)
+void DeclarativeScatter::setAxisX(Q3DValueAxis *axis)
 {
     m_shared->setAxisX(axis);
 }
 
-QValueAxis *DeclarativeScatter::axisY() const
+Q3DValueAxis *DeclarativeScatter::axisY() const
 {
-    return static_cast<QValueAxis *>(m_shared->axisY());
+    return static_cast<Q3DValueAxis *>(m_shared->axisY());
 }
 
-void DeclarativeScatter::setAxisY(QValueAxis *axis)
+void DeclarativeScatter::setAxisY(Q3DValueAxis *axis)
 {
     m_shared->setAxisY(axis);
 }
 
-QValueAxis *DeclarativeScatter::axisZ() const
+Q3DValueAxis *DeclarativeScatter::axisZ() const
 {
-    return static_cast<QValueAxis *>(m_shared->axisZ());
+    return static_cast<Q3DValueAxis *>(m_shared->axisZ());
 }
 
-void DeclarativeScatter::setAxisZ(QValueAxis *axis)
+void DeclarativeScatter::setAxisZ(Q3DValueAxis *axis)
 {
     m_shared->setAxisZ(axis);
 }
diff --git a/src/datavis3dqml2/declarativescatter_p.h b/src/datavis3dqml2/declarativescatter_p.h
index 449e99ad..187d1b89 100644
--- a/src/datavis3dqml2/declarativescatter_p.h
+++ b/src/datavis3dqml2/declarativescatter_p.h
@@ -33,7 +33,7 @@
 #include "scatter3dcontroller_p.h"
 #include "declarativescatter_p.h"
 #include "qitemmodelscatterdatamapping.h"
-#include "qvalueaxis.h"
+#include "q3dvalueaxis.h"
 
 #include <QAbstractItemModel>
 #include <QQuickItem>
@@ -46,9 +46,9 @@ class DeclarativeScatter : public QQuickItem
     Q_OBJECT
     Q_PROPERTY(const QAbstractItemModel *data READ data WRITE setData)
     Q_PROPERTY(QItemModelScatterDataMapping *mapping READ mapping WRITE setMapping)
-    Q_PROPERTY(QValueAxis *axisX READ axisX WRITE setAxisX)
-    Q_PROPERTY(QValueAxis *axisY READ axisY WRITE setAxisY)
-    Q_PROPERTY(QValueAxis *axisZ READ axisZ WRITE setAxisZ)
+    Q_PROPERTY(Q3DValueAxis *axisX READ axisX WRITE setAxisX)
+    Q_PROPERTY(Q3DValueAxis *axisY READ axisY WRITE setAxisY)
+    Q_PROPERTY(Q3DValueAxis *axisZ READ axisZ WRITE setAxisZ)
     Q_PROPERTY(QtDataVis3D::QDataVis::SelectionMode selectionMode READ selectionMode WRITE setSelectionMode)
     Q_PROPERTY(QtDataVis3D::QDataVis::LabelTransparency labelTransparency READ labelTransparency WRITE setLabelTransparency)
     Q_PROPERTY(QtDataVis3D::QDataVis::ShadowQuality shadowQuality READ shadowQuality WRITE setShadowQuality)
@@ -91,12 +91,12 @@ public:
     QItemModelScatterDataMapping *mapping() const;
     void setMapping(QItemModelScatterDataMapping *mapping);
 
-    QValueAxis *axisX() const;
-    void setAxisX(QValueAxis *axis);
-    QValueAxis *axisY() const;
-    void setAxisY(QValueAxis *axis);
-    QValueAxis *axisZ() const;
-    void setAxisZ(QValueAxis *axis);
+    Q3DValueAxis *axisX() const;
+    void setAxisX(Q3DValueAxis *axis);
+    Q3DValueAxis *axisY() const;
+    void setAxisY(Q3DValueAxis *axis);
+    Q3DValueAxis *axisZ() const;
+    void setAxisZ(Q3DValueAxis *axis);
 
     // Object type
     void setObjectType(QDataVis::MeshStyle style);