Rename "3d" -> "3D" in class names.

Change-Id: I9e861c28f828b3ee5b821e187396fb31c05844cb
Reviewed-by: Tomi Korpipää <tomi.korpipaa@digia.com>

27 files changed, 217 insertions, 219 deletions

diff --git a/src/datavis3d/axis/qabstractaxis.h b/src/datavis3d/axis/qabstractaxis.h
index e2c127ad..04c25af4 100644
--- a/src/datavis3d/axis/qabstractaxis.h
+++ b/src/datavis3d/axis/qabstractaxis.h
@@ -80,7 +80,7 @@ private:
     Q_DISABLE_COPY(QAbstractAxis)
 
     friend class Abstract3DController;
-    friend class Bars3dController;
+    friend class Bars3DController;
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/axis/qvalueaxis.h b/src/datavis3d/axis/qvalueaxis.h
index 1bffcb15..1d527feb 100644
--- a/src/datavis3d/axis/qvalueaxis.h
+++ b/src/datavis3d/axis/qvalueaxis.h
@@ -68,7 +68,7 @@ protected:
 
 private:
     Q_DISABLE_COPY(QValueAxis)
-    friend class Bars3dController;
+    friend class Bars3DController;
     friend class Scatter3DController;
 };
 
diff --git a/src/datavis3d/data/barrenderitem_p.h b/src/datavis3d/data/barrenderitem_p.h
index 67e1e256..e35cef08 100644
--- a/src/datavis3d/data/barrenderitem_p.h
+++ b/src/datavis3d/data/barrenderitem_p.h
@@ -33,7 +33,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class Bars3dRenderer;
+class Bars3DRenderer;
 
 class BarRenderItem : public AbstractRenderItem
 {
@@ -62,10 +62,10 @@ public:
     QString &sliceLabel(); // Formats label if not previously formatted
 
     // TODO should be in abstract, but currently there is no abstract renderer
-    inline void setRenderer(Bars3dRenderer *renderer) { m_renderer = renderer; }
+    inline void setRenderer(Bars3DRenderer *renderer) { m_renderer = renderer; }
 
 protected:
-    Bars3dRenderer *m_renderer;
+    Bars3DRenderer *m_renderer;
     qreal m_value;
     QPoint m_position; // x = row, y = column
     GLfloat m_height;
diff --git a/src/datavis3d/data/qabstractdataproxy.h b/src/datavis3d/data/qabstractdataproxy.h
index 50817a07..99b28e1f 100644
--- a/src/datavis3d/data/qabstractdataproxy.h
+++ b/src/datavis3d/data/qabstractdataproxy.h
@@ -63,7 +63,7 @@ private:
     Q_DISABLE_COPY(QAbstractDataProxy)
 
     friend class Abstract3DController;
-    friend class Bars3dController;
+    friend class Bars3DController;
     friend class Scatter3DController;
 };
 
diff --git a/src/datavis3d/data/qbardataproxy.h b/src/datavis3d/data/qbardataproxy.h
index 43b227df..51191739 100644
--- a/src/datavis3d/data/qbardataproxy.h
+++ b/src/datavis3d/data/qbardataproxy.h
@@ -100,7 +100,7 @@ protected:
 private:
     Q_DISABLE_COPY(QBarDataProxy)
 
-    friend class Bars3dController;
+    friend class Bars3DController;
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/bars3dcontroller.cpp b/src/datavis3d/engine/bars3dcontroller.cpp
index 26bc585f..a2607137 100644
--- a/src/datavis3d/engine/bars3dcontroller.cpp
+++ b/src/datavis3d/engine/bars3dcontroller.cpp
@@ -30,7 +30,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-Bars3dController::Bars3dController(QRect boundRect)
+Bars3DController::Bars3DController(QRect boundRect)
     : Abstract3DController(boundRect),
       m_rowCount(10),
       m_columnCount(10),
@@ -56,25 +56,25 @@ Bars3dController::Bars3dController(QRect boundRect)
     setAxisZ(0);
 }
 
-Bars3dController::~Bars3dController()
+Bars3DController::~Bars3DController()
 {
 }
 
-void Bars3dController::initializeOpenGL()
+void Bars3DController::initializeOpenGL()
 {
     // Initialization is called multiple times when Qt Quick components are used
     if (isInitialized())
         return;
 
-    m_renderer = new Bars3dRenderer(this);
+    m_renderer = new Bars3DRenderer(this);
     setRenderer(m_renderer);
     synchDataToRenderer();
 
-    QObject::connect(m_renderer, &Bars3dRenderer::selectedBarPosChanged, this,
-                     &Bars3dController::handleSelectedBarPosChanged, Qt::QueuedConnection);
+    QObject::connect(m_renderer, &Bars3DRenderer::selectedBarPosChanged, this,
+                     &Bars3DController::handleSelectedBarPosChanged, Qt::QueuedConnection);
 }
 
-void Bars3dController::synchDataToRenderer()
+void Bars3DController::synchDataToRenderer()
 {
     Abstract3DController::synchDataToRenderer();
 
@@ -108,7 +108,7 @@ void Bars3dController::synchDataToRenderer()
     }
 }
 
-QMatrix4x4 Bars3dController::calculateViewMatrix(int zoom, int viewPortWidth,
+QMatrix4x4 Bars3DController::calculateViewMatrix(int zoom, int viewPortWidth,
                                                  int viewPortHeight, bool showUnder)
 {
     return m_cameraHelper->calculateViewMatrix(m_mousePos,
@@ -118,12 +118,12 @@ QMatrix4x4 Bars3dController::calculateViewMatrix(int zoom, int viewPortWidth,
                                                showUnder);
 }
 
-bool Bars3dController::isSlicingActive()
+bool Bars3DController::isSlicingActive()
 {
     return m_isSlicingActivated;
 }
 
-void Bars3dController::setSlicingActive(bool isSlicing)
+void Bars3DController::setSlicingActive(bool isSlicing)
 {
     m_isSlicingActivated = isSlicing;
 
@@ -131,23 +131,23 @@ void Bars3dController::setSlicingActive(bool isSlicing)
     emit slicingActiveChanged(m_isSlicingActivated);
 }
 
-Bars3dController::MouseState Bars3dController::mouseState()
+Bars3DController::MouseState Bars3DController::mouseState()
 {
     return m_mouseState;
 }
 
 
 #if defined(Q_OS_ANDROID)
-void Bars3dController::mouseDoubleClickEvent(QMouseEvent *event)
+void Bars3DController::mouseDoubleClickEvent(QMouseEvent *event)
 {
     if (!m_isSlicingActivated) {
-        m_mouseState = Bars3dController::MouseOnScene;
+        m_mouseState = Bars3DController::MouseOnScene;
         // update mouse positions to prevent jumping when releasing or repressing a button
         m_mousePos = event->pos();
     }
 }
 
-void Bars3dController::touchEvent(QTouchEvent *event)
+void Bars3DController::touchEvent(QTouchEvent *event)
 {
     static int prevDistance = 0;
 
@@ -155,7 +155,7 @@ void Bars3dController::touchEvent(QTouchEvent *event)
     points = event->touchPoints();
 
     if (!m_isSlicingActivated && points.count() == 2) {
-        m_mouseState = Bars3dController::MouseOnPinch;
+        m_mouseState = Bars3DController::MouseOnPinch;
 
         QPointF distance = points.at(0).pos() - points.at(1).pos();
         int newDistance = distance.manhattanLength();
@@ -178,24 +178,24 @@ void Bars3dController::touchEvent(QTouchEvent *event)
 }
 #endif
 
-void Bars3dController::mousePressEvent(QMouseEvent *event, const QPoint &mousePos)
+void Bars3DController::mousePressEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     QRect mainViewPort = m_renderer->mainViewPort();
     if (Qt::LeftButton == event->button()) {
         if (m_isSlicingActivated) {
             if (mousePos.x() <= mainViewPort.width()
                     && mousePos.y() <= mainViewPort.height()) {
-                m_mouseState = Bars3dController::MouseOnOverview;
+                m_mouseState = Bars3DController::MouseOnOverview;
                 //qDebug() << "Mouse pressed on overview";
             } else {
-                m_mouseState = Bars3dController::MouseOnZoom;
+                m_mouseState = Bars3DController::MouseOnZoom;
                 //qDebug() << "Mouse pressed on zoom";
             }
         } else {
 #if !defined(Q_OS_ANDROID)
-            m_mouseState = Bars3dController::MouseOnScene;
+            m_mouseState = Bars3DController::MouseOnScene;
 #else
-            m_mouseState = Bars3dController::MouseRotating;
+            m_mouseState = Bars3DController::MouseRotating;
 #endif
             // update mouse positions to prevent jumping when releasing or repressing a button
             m_mousePos = mousePos;
@@ -207,9 +207,9 @@ void Bars3dController::mousePressEvent(QMouseEvent *event, const QPoint &mousePo
     } else if (!m_isSlicingActivated && Qt::RightButton == event->button()) {
         // disable rotating when in slice view
 #if !defined(Q_OS_ANDROID)
-        m_mouseState = Bars3dController::MouseRotating;
+        m_mouseState = Bars3DController::MouseRotating;
 #else
-        m_mouseState = Bars3dController::MouseOnScene;
+        m_mouseState = Bars3DController::MouseOnScene;
 #endif
         // update mouse positions to prevent jumping when releasing or repressing a button
         m_mousePos = mousePos;
@@ -217,25 +217,25 @@ void Bars3dController::mousePressEvent(QMouseEvent *event, const QPoint &mousePo
     m_cameraHelper->updateMousePos(m_mousePos);
 }
 
-void Bars3dController::mouseReleaseEvent(QMouseEvent *event, const QPoint &mousePos)
+void Bars3DController::mouseReleaseEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     Q_UNUSED(event);
-    if (Bars3dController::MouseRotating == m_mouseState) {
+    if (Bars3DController::MouseRotating == m_mouseState) {
         // update mouse positions to prevent jumping when releasing or repressing a button
         m_mousePos = mousePos;
         m_cameraHelper->updateMousePos(mousePos);
     }
-    m_mouseState = Bars3dController::MouseNone;
+    m_mouseState = Bars3DController::MouseNone;
 }
 
-void Bars3dController::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos)
+void Bars3DController::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     Q_UNUSED(event);
-    if (Bars3dController::MouseRotating == m_mouseState)
+    if (Bars3DController::MouseRotating == m_mouseState)
         m_mousePos = mousePos;
 }
 
-void Bars3dController::wheelEvent(QWheelEvent *event)
+void Bars3DController::wheelEvent(QWheelEvent *event)
 {
     // disable zooming if in slice view
     if (m_isSlicingActivated)
@@ -256,7 +256,7 @@ void Bars3dController::wheelEvent(QWheelEvent *event)
     setZoomLevel(zoomLevel);
 }
 
-void Bars3dController::setActiveDataProxy(QAbstractDataProxy *proxy)
+void Bars3DController::setActiveDataProxy(QAbstractDataProxy *proxy)
 {
     // Setting null proxy indicates default proxy
     if (!proxy) {
@@ -271,24 +271,24 @@ void Bars3dController::setActiveDataProxy(QAbstractDataProxy *proxy)
     QBarDataProxy *barDataProxy = static_cast<QBarDataProxy *>(m_data);
 
     QObject::connect(barDataProxy, &QBarDataProxy::arrayReset, this,
-                     &Bars3dController::handleArrayReset);
+                     &Bars3DController::handleArrayReset);
     QObject::connect(barDataProxy, &QBarDataProxy::rowsAdded, this,
-                     &Bars3dController::handleRowsAdded);
+                     &Bars3DController::handleRowsAdded);
     QObject::connect(barDataProxy, &QBarDataProxy::rowsChanged, this,
-                     &Bars3dController::handleRowsChanged);
+                     &Bars3DController::handleRowsChanged);
     QObject::connect(barDataProxy, &QBarDataProxy::rowsRemoved, this,
-                     &Bars3dController::handleRowsRemoved);
+                     &Bars3DController::handleRowsRemoved);
     QObject::connect(barDataProxy, &QBarDataProxy::rowsInserted, this,
-                     &Bars3dController::handleRowsInserted);
+                     &Bars3DController::handleRowsInserted);
     QObject::connect(barDataProxy, &QBarDataProxy::itemChanged, this,
-                     &Bars3dController::handleItemChanged);
+                     &Bars3DController::handleItemChanged);
 
     adjustValueAxisRange();
     m_isDataDirty = true;
     setSelectedBarPos(noSelectionPoint());
 }
 
-void Bars3dController::handleArrayReset()
+void Bars3DController::handleArrayReset()
 {
     setSlicingActive(false);
     adjustValueAxisRange();
@@ -296,7 +296,7 @@ void Bars3dController::handleArrayReset()
     setSelectedBarPos(noSelectionPoint());
 }
 
-void Bars3dController::handleRowsAdded(int startIndex, int count)
+void Bars3DController::handleRowsAdded(int startIndex, int count)
 {
     Q_UNUSED(startIndex)
     Q_UNUSED(count)
@@ -307,7 +307,7 @@ void Bars3dController::handleRowsAdded(int startIndex, int count)
     m_isDataDirty = true;
 }
 
-void Bars3dController::handleRowsChanged(int startIndex, int count)
+void Bars3DController::handleRowsChanged(int startIndex, int count)
 {
     Q_UNUSED(startIndex)
     Q_UNUSED(count)
@@ -318,7 +318,7 @@ void Bars3dController::handleRowsChanged(int startIndex, int count)
     m_isDataDirty = true;
 }
 
-void Bars3dController::handleRowsRemoved(int startIndex, int count)
+void Bars3DController::handleRowsRemoved(int startIndex, int count)
 {
     Q_UNUSED(startIndex)
     Q_UNUSED(count)
@@ -332,7 +332,7 @@ void Bars3dController::handleRowsRemoved(int startIndex, int count)
         setSelectedBarPos(noSelectionPoint());
 }
 
-void Bars3dController::handleRowsInserted(int startIndex, int count)
+void Bars3DController::handleRowsInserted(int startIndex, int count)
 {
     Q_UNUSED(startIndex)
     Q_UNUSED(count)
@@ -343,7 +343,7 @@ void Bars3dController::handleRowsInserted(int startIndex, int count)
     m_isDataDirty = true;
 }
 
-void Bars3dController::handleItemChanged(int rowIndex, int columnIndex)
+void Bars3DController::handleItemChanged(int rowIndex, int columnIndex)
 {
     Q_UNUSED(rowIndex)
     Q_UNUSED(columnIndex)
@@ -354,7 +354,7 @@ void Bars3dController::handleItemChanged(int rowIndex, int columnIndex)
     m_isDataDirty = true;
 }
 
-void Bars3dController::handleSelectedBarPosChanged(const QPoint &position)
+void Bars3DController::handleSelectedBarPosChanged(const QPoint &position)
 {
     QPoint pos = position;
     if (pos == QPoint(255, 255))
@@ -365,7 +365,7 @@ void Bars3dController::handleSelectedBarPosChanged(const QPoint &position)
     }
 }
 
-void Bars3dController::handleAxisAutoAdjustRangeChangedInOrientation(
+void Bars3DController::handleAxisAutoAdjustRangeChangedInOrientation(
         QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
@@ -373,13 +373,13 @@ void Bars3dController::handleAxisAutoAdjustRangeChangedInOrientation(
     adjustValueAxisRange();
 }
 
-QPoint Bars3dController::noSelectionPoint()
+QPoint Bars3DController::noSelectionPoint()
 {
     static QPoint noSelectionPos(-1, -1);
     return noSelectionPos;
 }
 
-void Bars3dController::setBarSpecs(GLfloat thicknessRatio, const QSizeF &spacing, bool relative)
+void Bars3DController::setBarSpecs(GLfloat thicknessRatio, const QSizeF &spacing, bool relative)
 {
     m_barThicknessRatio = thicknessRatio;
     m_barSpacing        = spacing;
@@ -389,22 +389,22 @@ void Bars3dController::setBarSpecs(GLfloat thicknessRatio, const QSizeF &spacing
     emit barSpecsChanged(thicknessRatio, spacing, relative);
 }
 
-GLfloat Bars3dController::barThickness()
+GLfloat Bars3DController::barThickness()
 {
     return m_barThicknessRatio;
 }
 
-QSizeF Bars3dController::barSpacing()
+QSizeF Bars3DController::barSpacing()
 {
     return m_barSpacing;
 }
 
-bool Bars3dController::isBarSpecRelative()
+bool Bars3DController::isBarSpecRelative()
 {
     return m_isBarSpecRelative;
 }
 
-void Bars3dController::setBarType(QDataVis::MeshStyle style, bool smooth)
+void Bars3DController::setBarType(QDataVis::MeshStyle style, bool smooth)
 {
     QString objFile;
     if (style == QDataVis::Bars)
@@ -425,7 +425,7 @@ void Bars3dController::setBarType(QDataVis::MeshStyle style, bool smooth)
 }
 
 // TODO: This sets data window. Needs more parameters, now assumes window always starts at 0,0.
-void Bars3dController::setDataWindow(int rowCount, int columnCount)
+void Bars3DController::setDataWindow(int rowCount, int columnCount)
 {
     // Disable zoom mode if we're in it (causes crash if not, as zoom selection is deleted)
     setSlicingActive(false);
@@ -443,14 +443,14 @@ void Bars3dController::setDataWindow(int rowCount, int columnCount)
     emit sampleSpaceChanged(rowCount, columnCount);
 }
 
-void Bars3dController::setSelectionMode(QDataVis::SelectionMode mode)
+void Bars3DController::setSelectionMode(QDataVis::SelectionMode mode)
 {
     // Disable zoom if selection mode changes
     setSlicingActive(false);
     Abstract3DController::setSelectionMode(mode);
 }
 
-void Bars3dController::setSelectedBarPos(const QPoint &position)
+void Bars3DController::setSelectedBarPos(const QPoint &position)
 {
     // TODO this will break once data window offset is implemented
     QPoint pos = position;
@@ -467,27 +467,27 @@ void Bars3dController::setSelectedBarPos(const QPoint &position)
     }
 }
 
-QPoint Bars3dController::selectedBarPos() const
+QPoint Bars3DController::selectedBarPos() const
 {
     return m_selectedBarPos;
 }
 
-QPoint Bars3dController::mousePosition()
+QPoint Bars3DController::mousePosition()
 {
     return m_mousePos;
 }
 
-int Bars3dController::columnCount()
+int Bars3DController::columnCount()
 {
     return m_columnCount;
 }
 
-int Bars3dController::rowCount()
+int Bars3DController::rowCount()
 {
     return m_rowCount;
 }
 
-void Bars3dController::adjustValueAxisRange()
+void Bars3DController::adjustValueAxisRange()
 {
     QValueAxis *valueAxis = static_cast<QValueAxis *>(m_axisY);
     if (valueAxis && valueAxis->isAutoAdjustRange() && m_data) {
@@ -507,7 +507,7 @@ void Bars3dController::adjustValueAxisRange()
     }
 }
 
-QAbstractAxis *Bars3dController::createDefaultAxis(QAbstractAxis::AxisOrientation orientation)
+QAbstractAxis *Bars3DController::createDefaultAxis(QAbstractAxis::AxisOrientation orientation)
 {
     QAbstractAxis *defaultAxis = 0;
 
diff --git a/src/datavis3d/engine/bars3dcontroller_p.h b/src/datavis3d/engine/bars3dcontroller_p.h
index 5ee5c214..aca669f5 100644
--- a/src/datavis3d/engine/bars3dcontroller_p.h
+++ b/src/datavis3d/engine/bars3dcontroller_p.h
@@ -36,7 +36,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class Bars3dRenderer;
+class Bars3DRenderer;
 class QBarDataProxy;
 
 struct Bars3DChangeBitField {
@@ -54,7 +54,7 @@ struct Bars3DChangeBitField {
     }
 };
 
-class QT_DATAVIS3D_EXPORT Bars3dController : public Abstract3DController
+class QT_DATAVIS3D_EXPORT Bars3DController : public Abstract3DController
 {
     Q_OBJECT
 
@@ -77,11 +77,11 @@ private:
     QSizeF m_barSpacing;
 
     // Rendering
-    Bars3dRenderer *m_renderer;
+    Bars3DRenderer *m_renderer;
 
 public:
-    explicit Bars3dController(QRect rect);
-    ~Bars3dController();
+    explicit Bars3DController(QRect rect);
+    ~Bars3DController();
 
     void initializeOpenGL();
     virtual void synchDataToRenderer();
@@ -156,7 +156,7 @@ protected:
 private:
     void adjustValueAxisRange();
 
-    Q_DISABLE_COPY(Bars3dController)
+    Q_DISABLE_COPY(Bars3DController)
 
 };
 
diff --git a/src/datavis3d/engine/bars3drenderer.cpp b/src/datavis3d/engine/bars3drenderer.cpp
index cb26a88c..ee28c58b 100644
--- a/src/datavis3d/engine/bars3drenderer.cpp
+++ b/src/datavis3d/engine/bars3drenderer.cpp
@@ -46,7 +46,7 @@ QT_DATAVIS3D_BEGIN_NAMESPACE
 const GLfloat gridLineWidth = 0.005f;
 static QVector3D selectionSkipColor = QVector3D(255, 255, 255); // Selection texture's background color
 
-Bars3dRenderer::Bars3dRenderer(Bars3dController *controller)
+Bars3DRenderer::Bars3DRenderer(Bars3DController *controller)
     : Abstract3DRenderer(controller),
       m_controller(controller),
       m_selectedBar(0),
@@ -92,7 +92,7 @@ Bars3dRenderer::Bars3dRenderer(Bars3dController *controller)
     initializeOpenGL();
 }
 
-Bars3dRenderer::~Bars3dRenderer()
+Bars3DRenderer::~Bars3DRenderer()
 {
     m_textureHelper->glDeleteFramebuffers(1, &m_selectionFrameBuffer);
     m_textureHelper->glDeleteRenderbuffers(1, &m_selectionDepthBuffer);
@@ -112,7 +112,7 @@ Bars3dRenderer::~Bars3dRenderer()
     delete m_gridLineObj;
 }
 
-void Bars3dRenderer::initializeOpenGL()
+void Bars3DRenderer::initializeOpenGL()
 {
     Abstract3DRenderer::initializeOpenGL();
 
@@ -144,7 +144,7 @@ void Bars3dRenderer::initializeOpenGL()
     loadBackgroundMesh();
 }
 
-void Bars3dRenderer::updateDataModel(QBarDataProxy *dataProxy)
+void Bars3DRenderer::updateDataModel(QBarDataProxy *dataProxy)
 {
     // Update cached data window
     int dataRowCount = dataProxy->rowCount();
@@ -170,7 +170,7 @@ void Bars3dRenderer::updateDataModel(QBarDataProxy *dataProxy)
     Abstract3DRenderer::updateDataModel(dataProxy);
 }
 
-void Bars3dRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
+void Bars3DRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
 {
     // Handle GL state setup for FBO buffers and clearing of the render surface
     Abstract3DRenderer::render(camera, defaultFboHandle);
@@ -191,7 +191,7 @@ void Bars3dRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
     drawScene(camera, defaultFboHandle);
 }
 
-void Bars3dRenderer::drawSlicedScene(CameraHelper *camera,
+void Bars3DRenderer::drawSlicedScene(CameraHelper *camera,
                                      const LabelItem &xLabel,
                                      const LabelItem &yLabel,
                                      const LabelItem &zLabel)
@@ -379,7 +379,7 @@ void Bars3dRenderer::drawSlicedScene(CameraHelper *camera,
     m_labelShader->release();
 }
 
-void Bars3dRenderer::drawScene(CameraHelper *camera,
+void Bars3DRenderer::drawScene(CameraHelper *camera,
                                const GLuint defaultFboHandle)
 {
     GLint startBar = 0;
@@ -655,7 +655,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
         glEnable(GL_DITHER);
 
         // Read color under cursor
-        if (Bars3dController::MouseOnScene == m_controller->mouseState())
+        if (Bars3DController::MouseOnScene == m_controller->mouseState())
             m_selection = Utils::getSelection(m_controller->mousePosition(), m_cachedBoundingRect.height());
 
         glBindFramebuffer(GL_FRAMEBUFFER, defaultFboHandle);
@@ -690,7 +690,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
 
     bool selectionDirty = (m_selection != m_previousSelection
             || (m_selection != selectionSkipColor
-                && Bars3dController::MouseOnScene == m_controller->mouseState()
+                && Bars3DController::MouseOnScene == m_controller->mouseState()
                 && !m_cachedIsSlicingActivated));
     if (selectionDirty) {
         m_previousSelection = m_selection;
@@ -748,10 +748,10 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
             GLfloat lightStrength = m_cachedTheme.m_lightStrength;
 
             if (m_cachedSelectionMode > QDataVis::ModeNone) {
-                Bars3dController::SelectionType selectionType = isSelected(row, bar);
+                Bars3DController::SelectionType selectionType = isSelected(row, bar);
 
                 switch (selectionType) {
-                case Bars3dController::SelectionItem: {
+                case Bars3DController::SelectionItem: {
                     barColor = Utils::vectorFromColor(m_cachedTheme.m_highlightBarColor);
                     lightStrength = m_cachedTheme.m_highlightLightStrength;
                     // Insert position data into render item. We have no ownership, don't delete the previous one
@@ -783,7 +783,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
                     }
                     break;
                 }
-                case Bars3dController::SelectionRow: {
+                case Bars3DController::SelectionRow: {
                     // Current bar is on the same row as the selected bar
                     barColor = Utils::vectorFromColor(m_cachedTheme.m_highlightRowColor);
                     lightStrength = m_cachedTheme.m_highlightLightStrength;
@@ -794,7 +794,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
                     }
                     break;
                 }
-                case Bars3dController::SelectionColumn: {
+                case Bars3DController::SelectionColumn: {
                     // Current bar is on the same column as the selected bar
                     barColor = Utils::vectorFromColor(m_cachedTheme.m_highlightColumnColor);
                     lightStrength = m_cachedTheme.m_highlightLightStrength;
@@ -805,7 +805,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
                     }
                     break;
                 }
-                case Bars3dController::SelectionNone: {
+                case Bars3DController::SelectionNone: {
                     // Current bar is not selected, nor on a row or column
                     // do nothing
                     break;
@@ -1318,7 +1318,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
         m_selectedBar = NULL;
         if (m_cachedIsSlicingActivated
                 && (m_selection == selectionSkipColor
-                    || Bars3dController::MouseOnOverview == m_controller->mouseState()))
+                    || Bars3DController::MouseOnOverview == m_controller->mouseState()))
             m_controller->setSlicingActive(false);
     } else if (m_cachedSelectionMode >= QDataVis::ModeSliceRow && selectionDirty) {
         // Activate slice mode
@@ -1401,7 +1401,7 @@ void Bars3dRenderer::drawScene(CameraHelper *camera,
     m_labelShader->release();
 }
 
-void Bars3dRenderer::handleResize()
+void Bars3DRenderer::handleResize()
 {
     if (m_cachedBoundingRect.width() == 0 || m_cachedBoundingRect.height() == 0)
         return;
@@ -1420,7 +1420,7 @@ void Bars3dRenderer::handleResize()
     Abstract3DRenderer::handleResize();
 }
 
-void Bars3dRenderer::updateBarSpecs(GLfloat thicknessRatio, QSizeF spacing, bool relative)
+void Bars3DRenderer::updateBarSpecs(GLfloat thicknessRatio, QSizeF spacing, bool relative)
 {
     // Convert ratio to QSizeF, as we need it in that format for autoscaling calculations
     m_cachedBarThickness.setWidth(1.0f);
@@ -1437,7 +1437,7 @@ void Bars3dRenderer::updateBarSpecs(GLfloat thicknessRatio, QSizeF spacing, bool
     calculateSceneScalingFactors();
 }
 
-void Bars3dRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
+void Bars3DRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation, qreal min, qreal max)
 {
     Abstract3DRenderer::updateAxisRange(orientation, min, max);
     calculateHeightAdjustment();
@@ -1458,7 +1458,7 @@ void Bars3dRenderer::updateAxisRange(QAbstractAxis::AxisOrientation orientation,
         qWarning() << __FUNCTION__ << "Bar chart currently properly supports only zero-centered and zero minimum ranges for Y-axis.";
 }
 
-void Bars3dRenderer::updateSampleSpace(int rowCount, int columnCount)
+void Bars3DRenderer::updateSampleSpace(int rowCount, int columnCount)
 {
     // Destroy old render items and reallocate new array
     // TODO is there a way to allocate the whole array with one allocation?
@@ -1486,7 +1486,7 @@ void Bars3dRenderer::updateSampleSpace(int rowCount, int columnCount)
     calculateSceneScalingFactors();
 }
 
-void Bars3dRenderer::updateSelectionMode(QDataVis::SelectionMode mode)
+void Bars3DRenderer::updateSelectionMode(QDataVis::SelectionMode mode)
 {
     Abstract3DRenderer::updateSelectionMode(mode);
 
@@ -1500,7 +1500,7 @@ void Bars3dRenderer::updateSelectionMode(QDataVis::SelectionMode mode)
     }
 }
 
-void Bars3dRenderer::updateBackgroundEnabled(bool enable)
+void Bars3DRenderer::updateBackgroundEnabled(bool enable)
 {
     if (enable != m_cachedIsBackgroundEnabled) {
         Abstract3DRenderer::updateBackgroundEnabled(enable);
@@ -1508,15 +1508,15 @@ void Bars3dRenderer::updateBackgroundEnabled(bool enable)
     }
 }
 
-void Bars3dRenderer::updateSelectedBarPos(QPoint position)
+void Bars3DRenderer::updateSelectedBarPos(QPoint position)
 {
-    if (position == Bars3dController::noSelectionPoint())
+    if (position == Bars3DController::noSelectionPoint())
         m_selection = selectionSkipColor;
     else
         m_selection = QVector3D(position.x(), position.y(), 0);
 }
 
-void Bars3dRenderer::updateShadowQuality(QDataVis::ShadowQuality quality)
+void Bars3DRenderer::updateShadowQuality(QDataVis::ShadowQuality quality)
 {
     m_cachedShadowQuality = quality;
     switch (quality) {
@@ -1542,7 +1542,7 @@ void Bars3dRenderer::updateShadowQuality(QDataVis::ShadowQuality quality)
 #endif
 }
 
-void Bars3dRenderer::loadMeshFile()
+void Bars3DRenderer::loadMeshFile()
 {
     QString objectFileName = m_cachedObjFile;
     if (m_barObj)
@@ -1554,7 +1554,7 @@ void Bars3dRenderer::loadMeshFile()
     m_barObj->load();
 }
 
-void Bars3dRenderer::loadBackgroundMesh()
+void Bars3DRenderer::loadBackgroundMesh()
 {
     if (m_backgroundObj)
         delete m_backgroundObj;
@@ -1565,7 +1565,7 @@ void Bars3dRenderer::loadBackgroundMesh()
     m_backgroundObj->load();
 }
 
-void Bars3dRenderer::loadGridLineMesh()
+void Bars3DRenderer::loadGridLineMesh()
 {
     if (m_gridLineObj)
         delete m_gridLineObj;
@@ -1573,7 +1573,7 @@ void Bars3dRenderer::loadGridLineMesh()
     m_gridLineObj->load();
 }
 
-void Bars3dRenderer::loadLabelMesh()
+void Bars3DRenderer::loadLabelMesh()
 {
     if (m_labelObj)
         delete m_labelObj;
@@ -1581,13 +1581,13 @@ void Bars3dRenderer::loadLabelMesh()
     m_labelObj->load();
 }
 
-void Bars3dRenderer::updateTextures()
+void Bars3DRenderer::updateTextures()
 {
     // Drawer has changed; this flag needs to be checked when checking if we need to update labels
     m_updateLabels = true;
 }
 
-void Bars3dRenderer::calculateSceneScalingFactors()
+void Bars3DRenderer::calculateSceneScalingFactors()
 {
     // Calculate scene scaling and translation factors
     m_rowWidth = ((m_cachedColumnCount + 1) * m_cachedBarSpacing.width()) / 2.0f;
@@ -1602,7 +1602,7 @@ void Bars3dRenderer::calculateSceneScalingFactors()
     //qDebug() << "m_rowWidth:" << m_rowWidth << "m_columnDepth:" << m_columnDepth << "m_maxDimension:" << m_maxDimension;
 }
 
-void Bars3dRenderer::calculateHeightAdjustment()
+void Bars3DRenderer::calculateHeightAdjustment()
 {
     m_heightNormalizer = (GLfloat)qMax(qFabs(m_axisCacheY.min()), qFabs(m_axisCacheY.max()));
 
@@ -1615,10 +1615,10 @@ void Bars3dRenderer::calculateHeightAdjustment()
     //qDebug() << m_yAdjustment;
 }
 
-Bars3dController::SelectionType Bars3dRenderer::isSelected(GLint row, GLint bar)
+Bars3DController::SelectionType Bars3DRenderer::isSelected(GLint row, GLint bar)
 {
     //static QVector3D prevSel = m_selection; // TODO: For debugging
-    Bars3dController::SelectionType isSelectedType = Bars3dController::SelectionNone;
+    Bars3DController::SelectionType isSelectedType = Bars3DController::SelectionNone;
     if (m_selection == selectionSkipColor)
         return isSelectedType; // skip window
 
@@ -1635,22 +1635,22 @@ Bars3dController::SelectionType Bars3dRenderer::isSelected(GLint row, GLint bar)
     //    prevSel = selection;
     //}
     if (current == m_selection) {
-        isSelectedType = Bars3dController::SelectionItem;
+        isSelectedType = Bars3DController::SelectionItem;
     }
     else if (current.y() == m_selection.y() && (m_cachedSelectionMode == QDataVis::ModeItemAndColumn
                                                 || m_cachedSelectionMode == QDataVis::ModeItemRowAndColumn
                                                 || m_cachedSelectionMode == QDataVis::ModeSliceColumn)) {
-        isSelectedType = Bars3dController::SelectionColumn;
+        isSelectedType = Bars3DController::SelectionColumn;
     }
     else if (current.x() == m_selection.x() && (m_cachedSelectionMode == QDataVis::ModeItemAndRow
                                                 || m_cachedSelectionMode == QDataVis::ModeItemRowAndColumn
                                                 || m_cachedSelectionMode == QDataVis::ModeSliceRow)) {
-        isSelectedType = Bars3dController::SelectionRow;
+        isSelectedType = Bars3DController::SelectionRow;
     }
     return isSelectedType;
 }
 
-void Bars3dRenderer::updateSlicingActive(bool isSlicing)
+void Bars3DRenderer::updateSlicingActive(bool isSlicing)
 {
     m_cachedIsSlicingActivated = isSlicing;
     if (isSlicing) {
@@ -1666,12 +1666,12 @@ void Bars3dRenderer::updateSlicingActive(bool isSlicing)
     }
 }
 
-QRect Bars3dRenderer::mainViewPort()
+QRect Bars3DRenderer::mainViewPort()
 {
     return m_mainViewPort;
 }
 
-void Bars3dRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader)
+void Bars3DRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader)
 {
     if (m_barShader)
         delete m_barShader;
@@ -1679,7 +1679,7 @@ void Bars3dRenderer::initShaders(const QString &vertexShader, const QString &fra
     m_barShader->initialize();
 }
 
-void Bars3dRenderer::initSelectionShader()
+void Bars3DRenderer::initSelectionShader()
 {
     if (m_selectionShader)
         delete m_selectionShader;
@@ -1688,7 +1688,7 @@ void Bars3dRenderer::initSelectionShader()
     m_selectionShader->initialize();
 }
 
-void Bars3dRenderer::initSelectionBuffer()
+void Bars3DRenderer::initSelectionBuffer()
 {
     if (m_cachedIsSlicingActivated)
         return;
@@ -1702,7 +1702,7 @@ void Bars3dRenderer::initSelectionBuffer()
 }
 
 #if !defined(QT_OPENGL_ES_2)
-void Bars3dRenderer::initDepthShader()
+void Bars3DRenderer::initDepthShader()
 {
     if (m_depthShader)
         delete m_depthShader;
@@ -1711,7 +1711,7 @@ void Bars3dRenderer::initDepthShader()
     m_depthShader->initialize();
 }
 
-void Bars3dRenderer::updateDepthBuffer()
+void Bars3DRenderer::updateDepthBuffer()
 {
     if (m_cachedIsSlicingActivated)
         return;
@@ -1751,7 +1751,7 @@ void Bars3dRenderer::updateDepthBuffer()
 }
 #endif
 
-void Bars3dRenderer::initBackgroundShaders(const QString &vertexShader,
+void Bars3DRenderer::initBackgroundShaders(const QString &vertexShader,
                                            const QString &fragmentShader)
 {
     if (m_backgroundShader)
@@ -1760,7 +1760,7 @@ void Bars3dRenderer::initBackgroundShaders(const QString &vertexShader,
     m_backgroundShader->initialize();
 }
 
-void Bars3dRenderer::initLabelShaders(const QString &vertexShader, const QString &fragmentShader)
+void Bars3DRenderer::initLabelShaders(const QString &vertexShader, const QString &fragmentShader)
 {
     if (m_labelShader)
         delete m_labelShader;
diff --git a/src/datavis3d/engine/bars3drenderer_p.h b/src/datavis3d/engine/bars3drenderer_p.h
index 5cd33809..d57a4e27 100644
--- a/src/datavis3d/engine/bars3drenderer_p.h
+++ b/src/datavis3d/engine/bars3drenderer_p.h
@@ -46,13 +46,13 @@ class ObjectHelper;
 class LabelItem;
 class CameraHelper;
 
-class QT_DATAVIS3D_EXPORT Bars3dRenderer : public Abstract3DRenderer
+class QT_DATAVIS3D_EXPORT Bars3DRenderer : public Abstract3DRenderer
 {
     Q_OBJECT
 
 private:
     // TODO: Filter to the set of attributes to be moved to the model object.
-    Bars3dController *m_controller;
+    Bars3DController *m_controller;
 
     // Cached state based on emitted signals from the controller
     QSizeF m_cachedBarThickness;
@@ -106,8 +106,8 @@ private:
     BarRenderItemArray m_renderItemArray;
 
 public:
-    explicit Bars3dRenderer(Bars3dController *controller);
-    ~Bars3dRenderer();
+    explicit Bars3DRenderer(Bars3DController *controller);
+    ~Bars3DRenderer();
 
     void updateDataModel(QBarDataProxy *dataProxy);
     void render(CameraHelper *camera, const GLuint defaultFboHandle = 0);
@@ -159,7 +159,7 @@ private:
     void calculateHeightAdjustment();
     Abstract3DController::SelectionType isSelected(GLint row, GLint bar);
 
-    Q_DISABLE_COPY(Bars3dRenderer)
+    Q_DISABLE_COPY(Bars3DRenderer)
 
     friend class BarRenderItem;
 };
diff --git a/src/datavis3d/engine/q3dbars.cpp b/src/datavis3d/engine/q3dbars.cpp
index a206a258..9d3ab7fa 100644
--- a/src/datavis3d/engine/q3dbars.cpp
+++ b/src/datavis3d/engine/q3dbars.cpp
@@ -95,12 +95,12 @@ Q3DBars::Q3DBars()
     : d_ptr(new Q3DBarsPrivate(this, geometry()))
 {
     d_ptr->m_shared->initializeOpenGL();
-    QObject::connect(d_ptr->m_shared, &Bars3dController::selectedBarPosChanged, this,
+    QObject::connect(d_ptr->m_shared, &Bars3DController::selectedBarPosChanged, this,
                      &Q3DBars::selectedBarPosChanged);
 }
 
 /*!
- *  Destroys the 3d bar window.
+ *  Destroys the 3D bar window.
  */
 Q3DBars::~Q3DBars()
 {
@@ -578,7 +578,7 @@ QList<QBarDataProxy *> Q3DBars::dataProxies() const
 
 Q3DBarsPrivate::Q3DBarsPrivate(Q3DBars *q, QRect rect)
     : q_ptr(q),
-      m_shared(new Bars3dController(rect))
+      m_shared(new Bars3DController(rect))
 {
     QObject::connect(m_shared, &Abstract3DController::shadowQualityChanged, this,
                      &Q3DBarsPrivate::handleShadowQualityUpdate);
diff --git a/src/datavis3d/engine/q3dbars_p.h b/src/datavis3d/engine/q3dbars_p.h
index d98473e6..f995cfbb 100644
--- a/src/datavis3d/engine/q3dbars_p.h
+++ b/src/datavis3d/engine/q3dbars_p.h
@@ -46,7 +46,7 @@ public:
     void handleShadowQualityUpdate(QDataVis::ShadowQuality quality);
 
     Q3DBars *q_ptr;
-    Bars3dController *m_shared;
+    Bars3DController *m_shared;
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/q3dsurface.cpp b/src/datavis3d/engine/q3dsurface.cpp
index c9d35a28..3426b2fe 100644
--- a/src/datavis3d/engine/q3dsurface.cpp
+++ b/src/datavis3d/engine/q3dsurface.cpp
@@ -292,7 +292,7 @@ void Q3DSurface::showData() const
 
 Q3DSurfacePrivate::Q3DSurfacePrivate(Q3DSurface *q, QRect rect)
     : q_ptr(q),
-      m_shared(new Surface3dController(rect))
+      m_shared(new Surface3DController(rect))
 {
 }
 
diff --git a/src/datavis3d/engine/q3dsurface_p.h b/src/datavis3d/engine/q3dsurface_p.h
index 1e92483b..7009af0f 100644
--- a/src/datavis3d/engine/q3dsurface_p.h
+++ b/src/datavis3d/engine/q3dsurface_p.h
@@ -51,7 +51,7 @@ public:
     // TODO
 
     Q3DSurface *q_ptr;
-    Surface3dController *m_shared;
+    Surface3DController *m_shared;
 
     QList<QList<qreal> > m_seriesList; // Temp to be replaced by dataset
 };
diff --git a/src/datavis3d/engine/selectionpointer.cpp b/src/datavis3d/engine/selectionpointer.cpp
index ab4279bd..c1b28f62 100644
--- a/src/datavis3d/engine/selectionpointer.cpp
+++ b/src/datavis3d/engine/selectionpointer.cpp
@@ -32,7 +32,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-SelectionPointer::SelectionPointer(Surface3dController *controller)
+SelectionPointer::SelectionPointer(Surface3DController *controller)
     : QObject(controller),
       m_controller(controller),
       m_labelShader(0),
diff --git a/src/datavis3d/engine/selectionpointer_p.h b/src/datavis3d/engine/selectionpointer_p.h
index 195089d8..19cada6f 100644
--- a/src/datavis3d/engine/selectionpointer_p.h
+++ b/src/datavis3d/engine/selectionpointer_p.h
@@ -55,7 +55,7 @@ class QT_DATAVIS3D_EXPORT SelectionPointer : public QObject, protected QOpenGLFu
     Q_OBJECT
 
 public:
-    explicit SelectionPointer(Surface3dController *controller);
+    explicit SelectionPointer(Surface3DController *controller);
     ~SelectionPointer();
 
     void initializeOpenGL();
@@ -72,7 +72,7 @@ private:
     void loadPointMesh();
 
 private:
-    Surface3dController *m_controller;
+    Surface3DController *m_controller;
     ShaderHelper *m_labelShader;
     ShaderHelper *m_pointShader;
     ObjectHelper *m_labelObj;
diff --git a/src/datavis3d/engine/surface3dcontroller.cpp b/src/datavis3d/engine/surface3dcontroller.cpp
index dd21f388..f5dec25e 100644
--- a/src/datavis3d/engine/surface3dcontroller.cpp
+++ b/src/datavis3d/engine/surface3dcontroller.cpp
@@ -30,7 +30,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-Surface3dController::Surface3dController(QRect rect)
+Surface3DController::Surface3DController(QRect rect)
     : Abstract3DController(rect),
       m_renderer(0),
       m_smoothSurface(false),
@@ -46,22 +46,22 @@ Surface3dController::Surface3dController(QRect rect)
     setAxisZ(0);
 }
 
-Surface3dController::~Surface3dController()
+Surface3DController::~Surface3DController()
 {
 }
 
-void Surface3dController::initializeOpenGL()
+void Surface3DController::initializeOpenGL()
 {
     // Initialization is called multiple times when Qt Quick components are used
     if (isInitialized())
         return;
 
-    m_renderer = new Surface3dRenderer(this);
+    m_renderer = new Surface3DRenderer(this);
     setRenderer(m_renderer);
     synchDataToRenderer();
 }
 
-void Surface3dController::synchDataToRenderer()
+void Surface3DController::synchDataToRenderer()
 {
     Abstract3DController::synchDataToRenderer();
 
@@ -71,7 +71,7 @@ void Surface3dController::synchDataToRenderer()
     // Notify changes to renderer
 }
 
-void Surface3dController::handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
+void Surface3DController::handleAxisAutoAdjustRangeChangedInOrientation(QAbstractAxis::AxisOrientation orientation, bool autoAdjust)
 {
     Q_UNUSED(orientation)
     Q_UNUSED(autoAdjust)
@@ -79,7 +79,7 @@ void Surface3dController::handleAxisAutoAdjustRangeChangedInOrientation(QAbstrac
     // TODO: Implement!
 }
 
-QMatrix4x4 Surface3dController::calculateViewMatrix(int zoom, int viewPortWidth, int viewPortHeight, bool showUnder)
+QMatrix4x4 Surface3DController::calculateViewMatrix(int zoom, int viewPortWidth, int viewPortHeight, bool showUnder)
 {
     return m_cameraHelper->calculateViewMatrix(m_mousePos,
                                                zoom,
@@ -88,31 +88,31 @@ QMatrix4x4 Surface3dController::calculateViewMatrix(int zoom, int viewPortWidth,
                                                showUnder);
 }
 
-void Surface3dController::setSmoothSurface(bool enable)
+void Surface3DController::setSmoothSurface(bool enable)
 {
     m_smoothSurface = enable;
     emit smoothStatusChanged(m_smoothSurface);
 }
 
-bool Surface3dController::smoothSurface()
+bool Surface3DController::smoothSurface()
 {
     return m_smoothSurface;
 }
 
-void Surface3dController::setSurfaceGrid(bool enable)
+void Surface3DController::setSurfaceGrid(bool enable)
 {
     m_surfaceGrid = enable;
     emit surfaceGridChanged(m_surfaceGrid);
 }
 
-bool Surface3dController::surfaceGrid()
+bool Surface3DController::surfaceGrid()
 {
     return m_surfaceGrid;
 }
 
 
 #if defined(Q_OS_ANDROID)
-void Surface3dController::mouseDoubleClickEvent(QMouseEvent *event)
+void Surface3DController::mouseDoubleClickEvent(QMouseEvent *event)
 {
     Q_UNUSED(event)
 }
@@ -122,7 +122,7 @@ void touchEvent(QTouchEvent *event)
 }
 #endif
 
-void Surface3dController::mousePressEvent(QMouseEvent *event, const QPoint &mousePos)
+void Surface3DController::mousePressEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     if (Qt::LeftButton == event->button()) {
         m_mousePos = mousePos;
@@ -139,7 +139,7 @@ void Surface3dController::mousePressEvent(QMouseEvent *event, const QPoint &mous
     m_cameraHelper->updateMousePos(m_mousePos);
 }
 
-void Surface3dController::mouseReleaseEvent(QMouseEvent *event, const QPoint &mousePos)
+void Surface3DController::mouseReleaseEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     Q_UNUSED(event)
     if (Abstract3DController::MouseRotating == m_mouseState) {
@@ -150,24 +150,24 @@ void Surface3dController::mouseReleaseEvent(QMouseEvent *event, const QPoint &mo
     m_mouseState = Abstract3DController::MouseNone;
 }
 
-void Surface3dController::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos)
+void Surface3DController::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos)
 {
     Q_UNUSED(event)
     if (Abstract3DController::MouseRotating == m_mouseState)
         m_mousePos = mousePos; //event->pos();
 }
 
-void Surface3dController::wheelEvent(QWheelEvent *event)
+void Surface3DController::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
 }
 
-QPoint Surface3dController::mousePosition()
+QPoint Surface3DController::mousePosition()
 {
     return m_mousePos;
 }
 
-void Surface3dController::setSegmentCount(GLint segmentCount, GLfloat step, GLfloat minimum)
+void Surface3DController::setSegmentCount(GLint segmentCount, GLfloat step, GLfloat minimum)
 {
     m_segmentCount   = segmentCount;
     m_segmentStep    = step;
@@ -176,7 +176,7 @@ void Surface3dController::setSegmentCount(GLint segmentCount, GLfloat step, GLfl
     emit segmentCountChanged(m_segmentCount, m_segmentStep, m_segmentMinimum);
 }
 
-void Surface3dController::setGradientColorAt(qreal pos, const QColor &color)
+void Surface3DController::setGradientColorAt(qreal pos, const QColor &color)
 {
     Theme t = theme();
     t.m_surfaceGradient.setColorAt(pos, color);
@@ -184,7 +184,7 @@ void Surface3dController::setGradientColorAt(qreal pos, const QColor &color)
 }
 
 // TODO: Temp
-void Surface3dController::setData(QList<qreal> series, int width, int depth)
+void Surface3DController::setData(QList<qreal> series, int width, int depth)
 {
     m_series = series;
     m_dataWidth = width;
diff --git a/src/datavis3d/engine/surface3dcontroller_p.h b/src/datavis3d/engine/surface3dcontroller_p.h
index a9c0945c..b120f36e 100644
--- a/src/datavis3d/engine/surface3dcontroller_p.h
+++ b/src/datavis3d/engine/surface3dcontroller_p.h
@@ -36,14 +36,14 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class Surface3dRenderer;
+class Surface3DRenderer;
 
-class QT_DATAVIS3D_EXPORT Surface3dController : public Abstract3DController
+class QT_DATAVIS3D_EXPORT Surface3DController : public Abstract3DController
 {
     Q_OBJECT
 
 private:
-    Surface3dRenderer *m_renderer;
+    Surface3DRenderer *m_renderer;
     QList<qreal> m_series; // TODO: TEMP
     int m_dataWidth;
     int m_dataDepth;
@@ -60,8 +60,8 @@ private:
     QDataVis::SelectionMode m_selectionMode;
 
 public:
-    explicit Surface3dController(QRect rect);
-    ~Surface3dController();
+    explicit Surface3DController(QRect rect);
+    ~Surface3DController();
 
     void initializeOpenGL();
     virtual void synchDataToRenderer();
@@ -106,7 +106,7 @@ signals:
     void leftMousePressed(const QPoint &point); // My temp solution
 
 private:
-    Q_DISABLE_COPY(Surface3dController)
+    Q_DISABLE_COPY(Surface3DController)
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/surface3drenderer.cpp b/src/datavis3d/engine/surface3drenderer.cpp
index b98b4347..013c8c03 100644
--- a/src/datavis3d/engine/surface3drenderer.cpp
+++ b/src/datavis3d/engine/surface3drenderer.cpp
@@ -46,7 +46,7 @@ const GLfloat backgroundBottom = 1.0f;
 const GLfloat gridLineWidth = 0.005f;
 const GLfloat coordRatio = 2.0f;
 
-Surface3dRenderer::Surface3dRenderer(Surface3dController *controller)
+Surface3DRenderer::Surface3DRenderer(Surface3DController *controller)
     : Abstract3DRenderer(controller),
       m_controller(controller),
       m_isGridEnabled(true),
@@ -90,14 +90,14 @@ Surface3dRenderer::Surface3dRenderer(Surface3dController *controller)
       m_yFlipped(false)
 {
     // Listen to changes in the controller
-    QObject::connect(m_controller, &Surface3dController::smoothStatusChanged, this,
-                     &Surface3dRenderer::updateSmoothStatus);
-    QObject::connect(m_controller, &Surface3dController::surfaceGridChanged, this,
-                     &Surface3dRenderer::updateSurfaceGridStatus);
-    QObject::connect(m_controller, &Surface3dController::segmentCountChanged, this,
-                     &Surface3dRenderer::updateSegmentCount);
-    QObject::connect(m_controller, &Surface3dController::leftMousePressed, this,
-                     &Surface3dRenderer::requestSelectionAtPoint); // TODO: Possible temp
+    QObject::connect(m_controller, &Surface3DController::smoothStatusChanged, this,
+                     &Surface3DRenderer::updateSmoothStatus);
+    QObject::connect(m_controller, &Surface3DController::surfaceGridChanged, this,
+                     &Surface3DRenderer::updateSurfaceGridStatus);
+    QObject::connect(m_controller, &Surface3DController::segmentCountChanged, this,
+                     &Surface3DRenderer::updateSegmentCount);
+    QObject::connect(m_controller, &Surface3DController::leftMousePressed, this,
+                     &Surface3DRenderer::requestSelectionAtPoint); // TODO: Possible temp
 
     m_cachedSmoothSurface =  m_controller->smoothSurface();
     updateSurfaceGridStatus(m_controller->surfaceGrid());
@@ -106,9 +106,9 @@ Surface3dRenderer::Surface3dRenderer(Surface3dController *controller)
     initializeOpenGL();
 }
 
-Surface3dRenderer::~Surface3dRenderer()
+Surface3DRenderer::~Surface3DRenderer()
 {
-    qDebug() << "Surface3dRenderer::~Surface3dRenderer()";
+    qDebug() << __FUNCTION__;
     m_textureHelper->glDeleteFramebuffers(1, &m_depthFrameBuffer);
     m_textureHelper->glDeleteRenderbuffers(1, &m_selectionDepthBuffer);
     m_textureHelper->glDeleteFramebuffers(1, &m_selectionFrameBuffer);
@@ -132,7 +132,7 @@ Surface3dRenderer::~Surface3dRenderer()
         delete m_selectionPointer;
 }
 
-void Surface3dRenderer::initializeOpenGL()
+void Surface3DRenderer::initializeOpenGL()
 {
     Abstract3DRenderer::initializeOpenGL();
 
@@ -176,7 +176,7 @@ void Surface3dRenderer::initializeOpenGL()
     updateSurfaceGradient();
 }
 
-void Surface3dRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
+void Surface3DRenderer::render(CameraHelper *camera, const GLuint defaultFboHandle)
 {
     if (defaultFboHandle) {
         glDepthMask(true);
@@ -204,10 +204,8 @@ void Surface3dRenderer::render(CameraHelper *camera, const GLuint defaultFboHand
         m_selectionPointer->render(camera, defaultFboHandle);
 }
 
-void Surface3dRenderer::drawScene(CameraHelper *camera, const GLuint defaultFboHandle)
+void Surface3DRenderer::drawScene(CameraHelper *camera, const GLuint defaultFboHandle)
 {
-    //qDebug() << "Surface3dRenderer::drawScene";
-
     GLfloat backgroundRotation = 0;
 
     // Specify viewport
@@ -702,7 +700,7 @@ void Surface3dRenderer::drawScene(CameraHelper *camera, const GLuint defaultFboH
     }
 }
 
-void Surface3dRenderer::updateSegmentCount(GLint segmentCount, GLfloat step, GLfloat minimum)
+void Surface3DRenderer::updateSegmentCount(GLint segmentCount, GLfloat step, GLfloat minimum)
 {
     m_segmentYCount = segmentCount;
     m_segmentYStep = step;
@@ -712,7 +710,7 @@ void Surface3dRenderer::updateSegmentCount(GLint segmentCount, GLfloat step, GLf
     }
 }
 
-void Surface3dRenderer::setXZStuff(GLint segmentXCount, GLint segmentZCount)
+void Surface3DRenderer::setXZStuff(GLint segmentXCount, GLint segmentZCount)
 {
     m_segmentXCount = segmentXCount;
     m_segmentZCount = segmentZCount;
@@ -724,7 +722,7 @@ void Surface3dRenderer::setXZStuff(GLint segmentXCount, GLint segmentZCount)
     calculateSceneScalingFactors();
 }
 
-void Surface3dRenderer::updateSurfaceGradient()
+void Surface3DRenderer::updateSurfaceGradient()
 {
     QImage image(QSize(4, 100), QImage::Format_RGB32);
     QPainter pmp(&image);
@@ -740,7 +738,7 @@ void Surface3dRenderer::updateSurfaceGradient()
     m_gradientTexture = m_textureHelper->create2DTexture(image, false, true);
 }
 
-void Surface3dRenderer::requestSelectionAtPoint(const QPoint &point)
+void Surface3DRenderer::requestSelectionAtPoint(const QPoint &point)
 {
     Q_UNUSED(point)
 
@@ -753,7 +751,7 @@ void Surface3dRenderer::requestSelectionAtPoint(const QPoint &point)
 }
 
 // This one needs to be called when the data size changes
-void Surface3dRenderer::updateSelectionTexture()
+void Surface3DRenderer::updateSelectionTexture()
 {
     // Create the selection ID image. Each grid corner gets 2x2 pixel area of
     // ID color so that each vertex (data point) has 4x4 pixel area of ID color
@@ -802,7 +800,7 @@ void Surface3dRenderer::updateSelectionTexture()
     delete bits;
 }
 
-void Surface3dRenderer::initSelectionBuffer()
+void Surface3DRenderer::initSelectionBuffer()
 {
     // Create the result selection texture and buffers
     if (m_selectionResultTexture) {
@@ -815,7 +813,7 @@ void Surface3dRenderer::initSelectionBuffer()
                                                                        m_selectionDepthBuffer);
 }
 
-void Surface3dRenderer::fillIdCorner(uchar *p, uchar r, uchar g, uchar b, uchar a, int stride)
+void Surface3DRenderer::fillIdCorner(uchar *p, uchar r, uchar g, uchar b, uchar a, int stride)
 {
     p[0] = r;
     p[1] = g;
@@ -835,7 +833,7 @@ void Surface3dRenderer::fillIdCorner(uchar *p, uchar r, uchar g, uchar b, uchar
     p[stride + 7] = a;
 }
 
-void Surface3dRenderer::idToRGBA(uint id, uchar *r, uchar *g, uchar *b, uchar *a)
+void Surface3DRenderer::idToRGBA(uint id, uchar *r, uchar *g, uchar *b, uchar *a)
 {
     *r = id & ID_TO_RGBA_MASK;
     *g = (id >> 8) & ID_TO_RGBA_MASK;
@@ -843,7 +841,7 @@ void Surface3dRenderer::idToRGBA(uint id, uchar *r, uchar *g, uchar *b, uchar *a
     *a = (id >> 24) & ID_TO_RGBA_MASK;
 }
 
-void Surface3dRenderer::setSeries(QList<qreal> series)
+void Surface3DRenderer::setSeries(QList<qreal> series)
 {
     m_series = series;
 
@@ -859,14 +857,14 @@ void Surface3dRenderer::setSeries(QList<qreal> series)
     updateSelectionTexture();
 }
 
-void Surface3dRenderer::updateTextures()
+void Surface3DRenderer::updateTextures()
 {
-    qDebug() << "Surface3dRenderer::updateTextures() NEED TO DO SOMETHING";
+    qDebug() << __FUNCTION__ << "NEED TO DO SOMETHING";
     // Drawer has changed; this flag needs to be checked when checking if we need to update labels
     //m_updateLabels = true;
 }
 
-void Surface3dRenderer::calculateSceneScalingFactors()
+void Surface3DRenderer::calculateSceneScalingFactors()
 {
     // Calculate scene scaling and translation factors
     m_xLength = m_segmentXCount;
@@ -886,7 +884,7 @@ void Surface3dRenderer::calculateSceneScalingFactors()
     //qDebug() << "m_rowWidth:" << m_rowWidth << "m_columnDepth:" << m_columnDepth << "m_maxDimension:" << m_maxDimension;
 }
 
-void Surface3dRenderer::updateSmoothStatus(bool enable)
+void Surface3DRenderer::updateSmoothStatus(bool enable)
 {
     m_cachedSmoothSurface = enable;
 
@@ -901,12 +899,12 @@ void Surface3dRenderer::updateSmoothStatus(bool enable)
     initSurfaceShaders();
 }
 
-void Surface3dRenderer::updateSurfaceGridStatus(bool enable)
+void Surface3DRenderer::updateSurfaceGridStatus(bool enable)
 {
     m_cachedSurfaceGridOn = enable;
 }
 
-void Surface3dRenderer::loadBackgroundMesh()
+void Surface3DRenderer::loadBackgroundMesh()
 {
     if (m_backgroundObj)
         delete m_backgroundObj;
@@ -917,7 +915,7 @@ void Surface3dRenderer::loadBackgroundMesh()
     m_backgroundObj->load();
 }
 
-void Surface3dRenderer::loadSurfaceObj()
+void Surface3DRenderer::loadSurfaceObj()
 {
     if (m_surfaceObj)
         delete m_surfaceObj;
@@ -925,7 +923,7 @@ void Surface3dRenderer::loadSurfaceObj()
     //m_surfaceObj->setUpData();
 }
 
-void Surface3dRenderer::loadGridLineMesh()
+void Surface3DRenderer::loadGridLineMesh()
 {
     if (m_gridLineObj)
         delete m_gridLineObj;
@@ -933,7 +931,7 @@ void Surface3dRenderer::loadGridLineMesh()
     m_gridLineObj->load();
 }
 
-void Surface3dRenderer::handleResize()
+void Surface3DRenderer::handleResize()
 {
     if (m_cachedBoundingRect.width() == 0 || m_cachedBoundingRect.height() == 0)
         return;
@@ -947,7 +945,7 @@ void Surface3dRenderer::handleResize()
 }
 
 #if !defined(QT_OPENGL_ES_2)
-void Surface3dRenderer::updateDepthBuffer()
+void Surface3DRenderer::updateDepthBuffer()
 {
     if (m_depthTexture) {
         m_textureHelper->deleteTexture(&m_depthTexture);
@@ -983,7 +981,7 @@ void Surface3dRenderer::updateDepthBuffer()
 }
 #endif
 
-void Surface3dRenderer::surfacePointSelected(qreal value, int column, int row)
+void Surface3DRenderer::surfacePointSelected(qreal value, int column, int row)
 {
     if (!m_selectionPointer)
         m_selectionPointer = new SelectionPointer(m_controller);
@@ -997,7 +995,7 @@ void Surface3dRenderer::surfacePointSelected(qreal value, int column, int row)
     m_selectionActive = true;
 }
 
-QVector3D Surface3dRenderer::normalize(float x, float y, float z)
+QVector3D Surface3DRenderer::normalize(float x, float y, float z)
 {
     float resX = x / ((float(m_segmentXCount) - 1.0f) / 2.0f) - 1.0f;
     float resY = y / (m_yRange / 2.0f) - 1.0f;
@@ -1006,7 +1004,7 @@ QVector3D Surface3dRenderer::normalize(float x, float y, float z)
     return QVector3D(resX, resY, resZ);
 }
 
-void Surface3dRenderer::surfacePointCleared()
+void Surface3DRenderer::surfacePointCleared()
 {
     if (m_selectionPointer) {
         delete m_selectionPointer;
@@ -1015,18 +1013,18 @@ void Surface3dRenderer::surfacePointCleared()
     }
 }
 
-void Surface3dRenderer::loadMeshFile()
+void Surface3DRenderer::loadMeshFile()
 {
-    qDebug() << "Surface3dRenderer::loadMeshFile() should we do something";
+    qDebug() << __FUNCTION__ << "should we do something";
 }
 
-void Surface3dRenderer::updateShadowQuality(QDataVis::ShadowQuality quality)
+void Surface3DRenderer::updateShadowQuality(QDataVis::ShadowQuality quality)
 {
     Q_UNUSED(quality)
-    qDebug() << "Surface3dRenderer::updateShadowQuality NEED TO DO SOMETHING";
+    qDebug() << __FUNCTION__ << "NEED TO DO SOMETHING";
 }
 
-void Surface3dRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader)
+void Surface3DRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader)
 {
     if (m_shader)
         delete m_shader;
@@ -1034,7 +1032,7 @@ void Surface3dRenderer::initShaders(const QString &vertexShader, const QString &
     m_shader->initialize();
 }
 
-void Surface3dRenderer::initBackgroundShaders(const QString &vertexShader,
+void Surface3DRenderer::initBackgroundShaders(const QString &vertexShader,
                                               const QString &fragmentShader)
 {
     if (m_backgroundShader)
@@ -1043,7 +1041,7 @@ void Surface3dRenderer::initBackgroundShaders(const QString &vertexShader,
     m_backgroundShader->initialize();
 }
 
-void Surface3dRenderer::initSelectionShaders()
+void Surface3DRenderer::initSelectionShaders()
 {
     if (m_selectionShader)
         delete m_selectionShader;
@@ -1052,7 +1050,7 @@ void Surface3dRenderer::initSelectionShaders()
     m_selectionShader->initialize();
 }
 
-void Surface3dRenderer::initSurfaceShaders()
+void Surface3DRenderer::initSurfaceShaders()
 {
     if (m_surfaceShader)
         delete m_surfaceShader;
diff --git a/src/datavis3d/engine/surface3drenderer_p.h b/src/datavis3d/engine/surface3drenderer_p.h
index eee66705..993acf8f 100644
--- a/src/datavis3d/engine/surface3drenderer_p.h
+++ b/src/datavis3d/engine/surface3drenderer_p.h
@@ -53,12 +53,12 @@ class Drawer;
 class CameraHelper;
 class SelectionPointer;
 
-class QT_DATAVIS3D_EXPORT Surface3dRenderer : public Abstract3DRenderer
+class QT_DATAVIS3D_EXPORT Surface3DRenderer : public Abstract3DRenderer
 {
     Q_OBJECT
 
 public:
-    Surface3dController *m_controller;
+    Surface3DController *m_controller;
 
     // Visual parameters
     QRect m_boundingRect;
@@ -116,8 +116,8 @@ protected:
     virtual void loadMeshFile();
 
 public:
-    explicit Surface3dRenderer(Surface3dController *controller);
-    ~Surface3dRenderer();
+    explicit Surface3DRenderer(Surface3DController *controller);
+    ~Surface3DRenderer();
 
     void initializeOpenGL();
     void render(CameraHelper *camera, const GLuint defaultFboHandle = 0);
@@ -158,7 +158,7 @@ private:
     void updateDepthBuffer();
 #endif
 
-    Q_DISABLE_COPY(Surface3dRenderer)
+    Q_DISABLE_COPY(Surface3DRenderer)
 };
 
 QT_DATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/theme_p.h b/src/datavis3d/engine/theme_p.h
index bebb2604..034be3c2 100644
--- a/src/datavis3d/engine/theme_p.h
+++ b/src/datavis3d/engine/theme_p.h
@@ -50,10 +50,10 @@ public:
 private:
     friend class Abstract3DController;
     friend class Abstract3DRenderer;
-    friend class Bars3dRenderer;
+    friend class Bars3DRenderer;
     friend class Maps3DController;
-    friend class Surface3dRenderer;
-    friend class Surface3dController;
+    friend class Surface3DRenderer;
+    friend class Surface3DController;
     friend class Scatter3DRenderer;
     friend class SelectionPointer;
     friend class Drawer;
diff --git a/src/datavis3d/utils/texturehelper_p.h b/src/datavis3d/utils/texturehelper_p.h
index e8f17d33..561816e5 100644
--- a/src/datavis3d/utils/texturehelper_p.h
+++ b/src/datavis3d/utils/texturehelper_p.h
@@ -61,9 +61,9 @@ class TextureHelper : protected QOpenGLFunctions
     void convertToGLFormatHelper(QImage &dstImage, const QImage &srcImage, GLenum texture_format);
     QRgb qt_gl_convertToGLFormatHelper(QRgb src_pixel, GLenum texture_format);
 
-    friend class Bars3dRenderer;
+    friend class Bars3DRenderer;
     friend class Maps3DController;
-    friend class Surface3dRenderer;
+    friend class Surface3DRenderer;
     friend class Scatter3DRenderer;
 };
 
diff --git a/src/datavis3dqml2/datavis3dqml2_plugin.cpp b/src/datavis3dqml2/datavis3dqml2_plugin.cpp
index d1e534f8..a2e755a9 100644
--- a/src/datavis3dqml2/datavis3dqml2_plugin.cpp
+++ b/src/datavis3dqml2/datavis3dqml2_plugin.cpp
@@ -22,7 +22,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-void Datavis3dqml2Plugin::registerTypes(const char *uri)
+void Datavis3Dqml2Plugin::registerTypes(const char *uri)
 {
     // @uri com.digia.QtDataVis3D
     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
diff --git a/src/datavis3dqml2/datavis3dqml2_plugin.h b/src/datavis3dqml2/datavis3dqml2_plugin.h
index ac88e1b5..bb967cf0 100644
--- a/src/datavis3dqml2/datavis3dqml2_plugin.h
+++ b/src/datavis3dqml2/datavis3dqml2_plugin.h
@@ -49,7 +49,7 @@ Q_DECLARE_METATYPE(QValueAxis *)
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-class Datavis3dqml2Plugin : public QQmlExtensionPlugin
+class Datavis3Dqml2Plugin : public QQmlExtensionPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
diff --git a/src/datavis3dqml2/declarativebars.cpp b/src/datavis3dqml2/declarativebars.cpp
index 4bb45232..91da8f64 100644
--- a/src/datavis3dqml2/declarativebars.cpp
+++ b/src/datavis3dqml2/declarativebars.cpp
@@ -40,7 +40,7 @@ DeclarativeBars::DeclarativeBars(QQuickItem *parent)
     setSmooth(true);
 
     // Create the shared component on the main GUI thread.
-    m_shared = new Bars3dController(boundingRect().toRect());
+    m_shared = new Bars3DController(boundingRect().toRect());
     QObject::connect(m_shared, &Abstract3DController::shadowQualityChanged, this,
                      &DeclarativeBars::handleShadowQualityUpdate);
 
diff --git a/src/datavis3dqml2/declarativebars_p.h b/src/datavis3dqml2/declarativebars_p.h
index 6ada9a35..2cbd24e0 100644
--- a/src/datavis3dqml2/declarativebars_p.h
+++ b/src/datavis3dqml2/declarativebars_p.h
@@ -187,7 +187,7 @@ signals:
     void dataResolved();
 
 protected:
-    Bars3dController *m_shared;
+    Bars3DController *m_shared;
 
     // Used to detect when shadow quality changes autonomously due to e.g. resizing.
     void handleShadowQualityUpdate(QDataVis::ShadowQuality quality);
diff --git a/src/datavis3dqml2/declarativebarsrenderer.cpp b/src/datavis3dqml2/declarativebarsrenderer.cpp
index 1ecd4003..4a76f70f 100644
--- a/src/datavis3dqml2/declarativebarsrenderer.cpp
+++ b/src/datavis3dqml2/declarativebarsrenderer.cpp
@@ -23,7 +23,7 @@
 
 QT_DATAVIS3D_BEGIN_NAMESPACE
 
-DeclarativeBarsRenderer::DeclarativeBarsRenderer(QQuickWindow *window, Bars3dController *renderer)
+DeclarativeBarsRenderer::DeclarativeBarsRenderer(QQuickWindow *window, Bars3DController *renderer)
     : m_fbo(0),
       m_texture(0),
       m_window(window),
diff --git a/src/datavis3dqml2/declarativebarsrenderer_p.h b/src/datavis3dqml2/declarativebarsrenderer_p.h
index 1b40d3df..7f721a23 100644
--- a/src/datavis3dqml2/declarativebarsrenderer_p.h
+++ b/src/datavis3dqml2/declarativebarsrenderer_p.h
@@ -44,7 +44,7 @@ class DeclarativeBarsRenderer : public QObject, public QSGSimpleTextureNode
     Q_OBJECT
 
 public:
-    DeclarativeBarsRenderer(QQuickWindow *window, Bars3dController *shared);
+    DeclarativeBarsRenderer(QQuickWindow *window, Bars3DController *shared);
     ~DeclarativeBarsRenderer();
 
 public slots:
@@ -57,7 +57,7 @@ private:
     QOpenGLFramebufferObject *m_fbo;
     QSGTexture *m_texture;
     QQuickWindow *m_window;
-    Bars3dController *m_barsRenderer;
+    Bars3DController *m_barsRenderer;
 };
 
 QT_DATAVIS3D_END_NAMESPACE