Object drawing and label generation moved to their own class

Change-Id: I3721b201dd83b471cb6d55f0dd7def908c4ab0be
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@digia.com>

15 files changed, 621 insertions, 375 deletions

diff --git a/src/datavis3d/engine/drawer.cpp b/src/datavis3d/engine/drawer.cpp
new file mode 100644
index 00000000..c33dd625
--- /dev/null
+++ b/src/datavis3d/engine/drawer.cpp
@@ -0,0 +1,169 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtDataVis3D module.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "drawer_p.h"
+#include "shaderhelper_p.h"
+#include "objecthelper_p.h"
+#include "qdataitem.h"
+#include "qdataitem_p.h"
+#include "utils_p.h"
+#include "texturehelper_p.h"
+
+QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
+
+Drawer::Drawer(const Theme &theme, const QFont &font, Q3DBars::LabelTransparency transparency)
+    : m_theme(theme),
+    m_font(font),
+    m_transparency(transparency),
+    m_textureHelper(new TextureHelper())
+{
+    initializeOpenGLFunctions();
+}
+
+Drawer::~Drawer()
+{
+
+}
+
+void Drawer::setTheme(const Theme &theme)
+{
+    m_theme = theme;
+}
+
+void Drawer::setFont(const QFont &font)
+{
+    m_font = font;
+}
+
+void Drawer::setTransparency(Q3DBars::LabelTransparency transparency)
+{
+    m_transparency = transparency;
+}
+
+void Drawer::drawObject(ShaderHelper *shader, ObjectHelper *object, bool textured,
+                        GLuint textureId)
+{
+    if (textured) {
+        // Activate texture
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, textureId);
+        shader->setUniformValue(shader->texture(), 0);
+    }
+
+    // 1st attribute buffer : vertices
+    glEnableVertexAttribArray(shader->posAtt());
+    glBindBuffer(GL_ARRAY_BUFFER, object->vertexBuf());
+    glVertexAttribPointer(shader->posAtt(), 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+
+    // 2nd attribute buffer : normals
+    glEnableVertexAttribArray(shader->normalAtt());
+    glBindBuffer(GL_ARRAY_BUFFER, object->normalBuf());
+    glVertexAttribPointer(shader->normalAtt(), 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+
+    if (textured) {
+        // 3rd attribute buffer : UVs
+        glEnableVertexAttribArray(shader->uvAtt());
+        glBindBuffer(GL_ARRAY_BUFFER, object->uvBuf());
+        glVertexAttribPointer(shader->uvAtt(), 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
+    }
+
+    // Index buffer
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, object->elementBuf());
+
+    // Draw the triangles
+    glDrawElements(GL_TRIANGLES, object->indexCount(), GL_UNSIGNED_SHORT, (void*)0);
+
+    // Free buffers
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+    if (textured) {
+        glBindTexture(GL_TEXTURE_2D, 0);
+        glDisableVertexAttribArray(shader->uvAtt());
+    }
+    glDisableVertexAttribArray(shader->normalAtt());
+    glDisableVertexAttribArray(shader->posAtt());
+}
+
+void Drawer::generateLabelTexture(QDataItem *item)
+{
+    // Delete previous texture, if there is one
+    GLuint labelTexture = item->d_ptr->textureId();
+    if (labelTexture) {
+        // We have to do this, as we can't know if data is static or not;
+        // texture doesn't change with static data
+        // (basically we could create textures for all bars when data is added, but we
+        // may not need them -> better to do it here dynamically)
+        glDeleteTextures(1, &labelTexture);
+        item->d_ptr->setTextureId(0);
+    }
+
+    // Create labels
+    // Print label into a QImage using QPainter
+    QImage label = Utils::printTextToImage(m_font,
+                                           item->d_ptr->valueStr(),
+                                           m_theme.m_textBackgroundColor,
+                                           m_theme.m_textColor,
+                                           m_transparency);
+
+    // Set label size
+    item->d_ptr->setLabelSize(label.size());
+    // Insert text texture into label
+    item->d_ptr->setTextureId(m_textureHelper->create2DTexture(label, true, true));
+}
+
+GLuint Drawer::generateLabelTexture(const QString &text, QSize &labelSize)
+{
+    // Create labels
+    // Print label into a QImage using QPainter
+    QImage label = Utils::printTextToImage(m_font,
+                                           text,
+                                           m_theme.m_textBackgroundColor,
+                                           m_theme.m_textColor,
+                                           m_transparency);
+
+    // Set label size
+    labelSize = label.size();
+    // Insert text texture into label
+    return m_textureHelper->create2DTexture(label, true, true);
+}
+
+QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/drawer_p.h b/src/datavis3d/engine/drawer_p.h
new file mode 100644
index 00000000..60cf06c5
--- /dev/null
+++ b/src/datavis3d/engine/drawer_p.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtDataVis3D module.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef DRAWER_P_H
+#define DRAWER_P_H
+
+#include "QtDataVis3D/qdatavis3dglobal.h"
+#include "q3dbars.h"
+#include "theme_p.h"
+#include <QFont>
+
+QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
+
+class QDataItem;
+class ShaderHelper;
+class ObjectHelper;
+class TextureHelper;
+
+class Drawer : protected QOpenGLFunctions
+{
+public:
+    explicit Drawer(const Theme &theme, const QFont &font, Q3DBars::LabelTransparency transparency);
+    ~Drawer();
+
+    void setTheme(const Theme &theme);
+    void setFont(const QFont &font);
+    void setTransparency(Q3DBars::LabelTransparency transparency);
+
+    void drawObject(ShaderHelper *shader, ObjectHelper *object, bool textured = false,
+                    GLuint textureId = 0);
+    void generateLabelTexture(QDataItem *item);
+    GLuint generateLabelTexture(const QString &text, QSize &labelSize);
+
+private:
+    Theme m_theme;
+    QFont m_font;
+    Q3DBars::LabelTransparency m_transparency;
+    TextureHelper *m_textureHelper;
+};
+
+QTCOMMERCIALDATAVIS3D_END_NAMESPACE
+
+#endif
diff --git a/src/datavis3d/engine/engine.pri b/src/datavis3d/engine/engine.pri
index 7b5c7a67..e9d3fbb9 100644
--- a/src/datavis3d/engine/engine.pri
+++ b/src/datavis3d/engine/engine.pri
@@ -3,7 +3,8 @@ SOURCES += $$PWD/q3dwindow.cpp \
            $$PWD/qdataitem.cpp \
            $$PWD/qdatarow.cpp \
            $$PWD/qdataset.cpp \
-           $$PWD/theme.cpp
+           $$PWD/theme.cpp \
+           $$PWD/drawer.cpp
 
 HEADERS += $$PWD/q3dwindow_p.h \
            $$PWD/q3dwindow.h \
@@ -15,6 +16,7 @@ HEADERS += $$PWD/q3dwindow_p.h \
            $$PWD/qdatarow_p.h \
            $$PWD/qdataset.h \
            $$PWD/qdataset_p.h \
-           $$PWD/theme_p.h
+           $$PWD/theme_p.h \
+           $$PWD/drawer_p.h
 
 RESOURCES += engine/engine.qrc
diff --git a/src/datavis3d/engine/q3dbars.cpp b/src/datavis3d/engine/q3dbars.cpp
index 5dc6b753..218351f0 100644
--- a/src/datavis3d/engine/q3dbars.cpp
+++ b/src/datavis3d/engine/q3dbars.cpp
@@ -50,6 +50,7 @@
 #include "texturehelper_p.h"
 #include "theme_p.h"
 #include "utils_p.h"
+#include "drawer_p.h"
 
 #include <QMatrix4x4>
 #include <QOpenGLPaintDevice>
@@ -88,19 +89,19 @@ void Q3DBars::initialize()
 {
     // Initialize shaders
     if (!d_ptr->m_theme->m_uniformColor) {
-        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                           , QStringLiteral(":/shaders/fragmentColorOnY"));
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                           QStringLiteral(":/shaders/fragmentColorOnY"));
     } else {
-        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                           , QStringLiteral(":/shaders/fragment"));
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                           QStringLiteral(":/shaders/fragment"));
     }
-//    d_ptr->initBackgroundShaders(QStringLiteral(":/shaders/vertexTexture")
-//                                 , QStringLiteral(":/shaders/fragmentTexture"));
-    d_ptr->initBackgroundShaders(QStringLiteral(":/shaders/vertex")
-                                 , QStringLiteral(":/shaders/fragment"));
+    //    d_ptr->initBackgroundShaders(QStringLiteral(":/shaders/vertexTexture"),
+    //                                 QStringLiteral(":/shaders/fragmentTexture"));
+    d_ptr->initBackgroundShaders(QStringLiteral(":/shaders/vertex"),
+                                 QStringLiteral(":/shaders/fragment"));
 #ifndef USE_PAINTER_TEXT
-    d_ptr->initLabelShaders(QStringLiteral(":/shaders/vertexLabel")
-                            , QStringLiteral(":/shaders/fragmentLabel"));
+    d_ptr->initLabelShaders(QStringLiteral(":/shaders/vertexLabel"),
+                            QStringLiteral(":/shaders/fragmentLabel"));
 #endif
     d_ptr->initSelectionShader();
 
@@ -128,9 +129,9 @@ void Q3DBars::initialize()
 
     // Set initial camera position
     // X must be 0 for rotation to work - we can use "setCameraRotation" for setting it later
-    CameraHelper::setDefaultCameraOrientation(QVector3D(0.0f, 0.0f, 6.0f + zComp)
-                                              , QVector3D(0.0f, 0.0f, zComp)
-                                              , QVector3D(0.0f, 1.0f, 0.0f));
+    CameraHelper::setDefaultCameraOrientation(QVector3D(0.0f, 0.0f, 6.0f + zComp),
+                                              QVector3D(0.0f, 0.0f, zComp),
+                                              QVector3D(0.0f, 1.0f, 0.0f));
 
     // Set view port
     glViewport(0, 0, width(), height());
@@ -159,7 +160,7 @@ void Q3DBars::render()
     // Measure speed (as milliseconds per frame)
     nbFrames++;
     if (lastTime.elapsed() >= 1000) { // print only if last measurement was more than 1s ago
-        qDebug() << double(lastTime.elapsed()) / double(nbFrames) << "ms/frame (=" << double(nbFrames) << "fps)";
+        qDebug() << qreal(lastTime.elapsed()) / qreal(nbFrames) << "ms/frame (=" << qreal(nbFrames) << "fps)";
         nbFrames = 0;
         lastTime.restart();
     }
@@ -271,8 +272,8 @@ void Q3DBars::drawZoomScene()
     QVector3D lightPos;
 
     // Specify viewport
-    glViewport(d_ptr->m_zoomViewPort.x(), d_ptr->m_zoomViewPort.y()
-               , d_ptr->m_zoomViewPort.width(), d_ptr->m_zoomViewPort.height());
+    glViewport(d_ptr->m_zoomViewPort.x(), d_ptr->m_zoomViewPort.y(),
+               d_ptr->m_zoomViewPort.width(), d_ptr->m_zoomViewPort.height());
 
     // Set up projection matrix
     QMatrix4x4 projectionMatrix;
@@ -281,10 +282,10 @@ void Q3DBars::drawZoomScene()
 
 #ifdef ROTATE_ZOOM_SELECTION
     // Calculate view matrix
-    QMatrix4x4 viewMatrix = CameraHelper::calculateViewMatrix(d_ptr->m_mousePos
-                                                              , d_ptr->m_zoomLevel
-                                                              , d_ptr->m_zoomViewPort.width()
-                                                              , d_ptr->m_zoomViewPort.height());
+    QMatrix4x4 viewMatrix = CameraHelper::calculateViewMatrix(d_ptr->m_mousePos,
+                                                              d_ptr->m_zoomLevel,
+                                                              d_ptr->m_zoomViewPort.width(),
+                                                              d_ptr->m_zoomViewPort.height());
 
     // Get light position (rotate light with camera, a bit above it (as set in defaultLightPos))
     lightPos = CameraHelper::calculateLightPosition(defaultLightPos);
@@ -298,13 +299,13 @@ void Q3DBars::drawZoomScene()
     // Set view matrix
     QMatrix4x4 viewMatrix;
 #if 1
-    viewMatrix.lookAt(QVector3D(0.0f, 0.0f, 5.0f + zComp)
-                      , QVector3D(0.0f, 0.0f, zComp)
-                      , QVector3D(0.0f, 1.0f, 0.0f));
+    viewMatrix.lookAt(QVector3D(0.0f, 0.0f, 5.0f + zComp),
+                      QVector3D(0.0f, 0.0f, zComp),
+                      QVector3D(0.0f, 1.0f, 0.0f));
 #else
-    viewMatrix.lookAt(QVector3D(0.0f, 0.0f, d_ptr->m_scaleFactorX + zComp)
-                      , QVector3D(0.0f, 0.0f, zComp)
-                      , QVector3D(0.0f, 1.0f, 0.0f));
+    viewMatrix.lookAt(QVector3D(0.0f, 0.0f, d_ptr->m_scaleFactorX + zComp),
+                      QVector3D(0.0f, 0.0f, zComp),
+                      QVector3D(0.0f, 1.0f, 0.0f));
     float zoomwidth;
     if (ZoomRow == d_ptr->m_selectionMode) {
         zoomwidth = d_ptr->m_zoomSelection->d_ptr->getItem(0)->d_ptr->translation().x()
@@ -337,7 +338,7 @@ void Q3DBars::drawZoomScene()
     d_ptr->m_barShader->bind();
 
     // Draw bars
-//    bool barSelectionFound = false;
+    //    bool barSelectionFound = false;
     // Draw the selected row / column
     for (int bar = startBar; bar != stopBar; bar += stepBar) {
         QDataItem *item = d_ptr->m_zoomSelection->d_ptr->getItem(bar);
@@ -350,9 +351,9 @@ void Q3DBars::drawZoomScene()
             barPosX = item->d_ptr->translation().x();
         else
             barPosX = -(item->d_ptr->translation().z() - zComp); // flip z; frontmost bar to the left
-        modelMatrix.translate(barPosX
-                              , item->d_ptr->translation().y() - 0.5f// TODO: Needs a better system; calculate y position modifier somehow
-                              , zComp);
+        modelMatrix.translate(barPosX,
+                              item->d_ptr->translation().y() - 0.5f,// TODO: Needs a better system; calculate y position modifier somehow
+                              zComp);
         modelMatrix.scale(QVector3D(d_ptr->m_scaleX, barHeight, d_ptr->m_scaleZ));
 
         MVPMatrix = projectionMatrix * viewMatrix * modelMatrix;
@@ -365,8 +366,7 @@ void Q3DBars::drawZoomScene()
         float lightStrength = d_ptr->m_theme->m_lightStrength;
 #if 0 // TODO: Implement selection in zoom
         if (d_ptr->m_selectionMode > None) {
-            Q3DBarsPrivate::SelectionType selectionType = d_ptr->isSelected(row, bar
-                                                                            , selection);
+            Q3DBarsPrivate::SelectionType selectionType = d_ptr->isSelected(row, bar, selection);
             switch (selectionType) {
             case Q3DBarsPrivate::Bar:
             {
@@ -411,16 +411,16 @@ void Q3DBars::drawZoomScene()
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightP(), lightPos);
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->view(), viewMatrix);
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->model(), modelMatrix);
-        d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->nModel()
-                                            , modelMatrix.inverted().transposed());
+        d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->nModel(),
+                                            modelMatrix.inverted().transposed());
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->MVP(), MVPMatrix);
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->color(), barColor);
         d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightS(), lightStrength);
-        d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->ambientS()
-                                            , d_ptr->m_theme->m_ambientStrength);
+        d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->ambientS(),
+                                            d_ptr->m_theme->m_ambientStrength);
 
         // Draw the object
-        drawObject(d_ptr->m_barShader, d_ptr->m_barObj);
+        d_ptr->m_drawer->drawObject(d_ptr->m_barShader, d_ptr->m_barObj);
     }
 #if 0
     if (!barSelectionFound) {
@@ -431,17 +431,17 @@ void Q3DBars::drawZoomScene()
             d_ptr->m_zoomActivated = false;
         }
     } else if (d_ptr->m_selectionMode >= ZoomRow
-             && Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed) {
+               && Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed) {
         d_ptr->m_zoomActivated = true;
-        d_ptr->m_sceneViewPort = QRect(0, height() - height() / 5
-                                       , width() / 5, height() / 5);
+        d_ptr->m_sceneViewPort = QRect(0, height() - height() / 5,
+                                       width() / 5, height() / 5);
     }
 #endif
     // Release bar shader
     d_ptr->m_barShader->release();
 
 #ifndef USE_PAINTER_TEXT
-    // Draw bar values
+    // Draw labels
     d_ptr->m_labelShader->bind();
     glDisable(GL_DEPTH_TEST);
     glEnable(GL_TEXTURE_2D);
@@ -450,10 +450,23 @@ void Q3DBars::drawZoomScene()
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
-    // Do the actual drawing
     for (int col = 0; col < d_ptr->m_zoomSelection->d_ptr->row().size(); col++) {
         QDataItem *item = d_ptr->m_zoomSelection->d_ptr->getItem(col);
-        drawLabel(*item, viewMatrix, projectionMatrix, false, -45.0f);
+        // Draw values
+        drawLabel(*item, item->d_ptr->textureId(), viewMatrix, projectionMatrix, false, 0.0f,
+                  LabelOver);
+        // Draw labels // TODO: Generate label textures
+        if (ZoomRow == d_ptr->m_selectionMode) {
+            drawLabel(*item, item->d_ptr->textureId(), viewMatrix, projectionMatrix, false, -45.0f,
+                      LabelBelow);
+            //            drawLabel(*item, d_ptr->m_dataSet->d_ptr->rowLabels().at(col), viewMatrix,
+            //                      projectionMatrix, false, -45.0f, LabelBelow);
+        } else {
+            drawLabel(*item, item->d_ptr->textureId(), viewMatrix, projectionMatrix, false, -45.0f,
+                      LabelBelow);
+            //            drawLabel(*item, d_ptr->m_dataSet->d_ptr->columnLabels().at(col), viewMatrix,
+            //                      projectionMatrix, false, -45.0f, LabelBelow);
+        }
     }
 
     glDisable(GL_TEXTURE_2D);
@@ -484,8 +497,8 @@ void Q3DBars::drawScene()
     static QVector3D selection = QVector3D(0, 0, 0);
 
     // Specify viewport
-    glViewport(d_ptr->m_sceneViewPort.x(), d_ptr->m_sceneViewPort.y()
-               , d_ptr->m_sceneViewPort.width(), d_ptr->m_sceneViewPort.height());
+    glViewport(d_ptr->m_sceneViewPort.x(), d_ptr->m_sceneViewPort.y(),
+               d_ptr->m_sceneViewPort.width(), d_ptr->m_sceneViewPort.height());
 
     // Set up projection matrix
     QMatrix4x4 projectionMatrix;
@@ -493,10 +506,10 @@ void Q3DBars::drawScene()
                                  / (float)d_ptr->m_sceneViewPort.height(), 0.1f, 100.0f);
 
     // Calculate view matrix
-    QMatrix4x4 viewMatrix = CameraHelper::calculateViewMatrix(d_ptr->m_mousePos
-                                                              , d_ptr->m_zoomLevel
-                                                              , d_ptr->m_sceneViewPort.width()
-                                                              , d_ptr->m_sceneViewPort.height());
+    QMatrix4x4 viewMatrix = CameraHelper::calculateViewMatrix(d_ptr->m_mousePos,
+                                                              d_ptr->m_zoomLevel,
+                                                              d_ptr->m_sceneViewPort.width(),
+                                                              d_ptr->m_sceneViewPort.height());
     if (d_ptr->m_sceneViewPort.height() > d_ptr->m_sceneViewPort.width()) {
         viewMatrix.scale((float)d_ptr->m_sceneViewPort.width()
                          / (float)d_ptr->m_sceneViewPort.height());
@@ -527,15 +540,14 @@ void Q3DBars::drawScene()
     }
 
     // calculate background rotation based on view matrix rotation
-    if (viewMatrix.row(0).x() >= 0 && viewMatrix.row(0).z() <= 0) {
+    if (viewMatrix.row(0).x() >= 0 && viewMatrix.row(0).z() <= 0)
         backgroundRotation = 270.0f;
-    } else if (viewMatrix.row(0).x() > 0 && viewMatrix.row(0).z() > 0) {
+    else if (viewMatrix.row(0).x() > 0 && viewMatrix.row(0).z() > 0)
         backgroundRotation = 180.0f;
-    } else if (viewMatrix.row(0).x() <= 0 && viewMatrix.row(0).z() >= 0) {
+    else if (viewMatrix.row(0).x() <= 0 && viewMatrix.row(0).z() >= 0)
         backgroundRotation = 90.0f;
-    } else if (viewMatrix.row(0).x() < 0 && viewMatrix.row(0).z() < 0) {
+    else if (viewMatrix.row(0).x() < 0 && viewMatrix.row(0).z() < 0)
         backgroundRotation = 0.0f;
-    }
 
     // Get light position (rotate light with camera, a bit above it (as set in defaultLightPos))
     QVector3D lightPos = CameraHelper::calculateLightPosition(defaultLightPos);
@@ -559,36 +571,39 @@ void Q3DBars::drawScene()
                 QMatrix4x4 MVPMatrix;
                 barPos = (bar + 1) * (d_ptr->m_barSpacing.x());
                 rowPos = (row + 1) * (d_ptr->m_barSpacing.y());
-                modelMatrix.translate((d_ptr->m_rowWidth - barPos) / d_ptr->m_scaleFactorX
-                                      , barHeight - 1.0f
-                                      , (d_ptr->m_columnDepth - rowPos) / d_ptr->m_scaleFactorZ + zComp);
+                modelMatrix.translate((d_ptr->m_rowWidth - barPos) / d_ptr->m_scaleFactorX,
+                                      barHeight - 1.0f,
+                                      (d_ptr->m_columnDepth - rowPos) / d_ptr->m_scaleFactorZ
+                                      + zComp);
                 modelMatrix.scale(QVector3D(d_ptr->m_scaleX, barHeight, d_ptr->m_scaleZ));
 
                 MVPMatrix = projectionMatrix * viewMatrix * modelMatrix;
 
                 // add +2 to avoid black
-                QVector3D barColor = QVector3D((float)(row + 2) / (float)(d_ptr->m_sampleCount.y() + 2)
-                                               , (float)(bar + 2) / (float)(d_ptr->m_sampleCount.x() + 2)
-                                               , 0.0f);
+                QVector3D barColor = QVector3D((float)(row + 2)
+                                               / (float)(d_ptr->m_sampleCount.y() + 2),
+                                               (float)(bar + 2)
+                                               / (float)(d_ptr->m_sampleCount.x() + 2),
+                                               0.0f);
 
-                d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->MVP()
-                                                          , MVPMatrix);
-                d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->color()
-                                                          , barColor);
+                d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->MVP(),
+                                                          MVPMatrix);
+                d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->color(),
+                                                          barColor);
 
 #ifdef USE_HAX0R_SELECTION
                 // 1st attribute buffer : vertices
                 glEnableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
                 glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_barObj->vertexBuf());
-                glVertexAttribPointer(d_ptr->m_selectionShader->posAtt()
-                                      , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+                glVertexAttribPointer(d_ptr->m_selectionShader->posAtt(),
+                                      3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
                 // Index buffer
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, d_ptr->m_barObj->elementBuf());
 
                 // Draw the triangles
-                glDrawElements(GL_TRIANGLES, d_ptr->m_barObj->indexCount()
-                               , GL_UNSIGNED_SHORT, (void*)0);
+                glDrawElements(GL_TRIANGLES, d_ptr->m_barObj->indexCount(),
+                               GL_UNSIGNED_SHORT, (void*)0);
 
                 // Free buffers
                 glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -602,16 +617,16 @@ void Q3DBars::drawScene()
                 // 1st attribute buffer : vertices
                 glEnableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
                 glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_barObj->vertexBuf());
-                glVertexAttribPointer(d_ptr->m_selectionShader->posAtt()
-                                      , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+                glVertexAttribPointer(d_ptr->m_selectionShader->posAtt(),
+                                      3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
                 // Index buffer
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, d_ptr->m_barObj->elementBuf());
 
                 // Draw the triangles
                 GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
-                glDrawElements(GL_TRIANGLES, d_ptr->m_barObj->indexCount()
-                               , GL_UNSIGNED_SHORT, DrawBuffers);
+                glDrawElements(GL_TRIANGLES, d_ptr->m_barObj->indexCount(),
+                               GL_UNSIGNED_SHORT, DrawBuffers);
 
                 glDisableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
 
@@ -627,9 +642,8 @@ void Q3DBars::drawScene()
         glEnable(GL_DITHER);
 
         // Read color under cursor
-        if (Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed) {
+        if (Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed)
             selection = Utils::getSelection(d_ptr->m_mousePos, height());
-        }
 
         // Release selection shader
         d_ptr->m_selectionShader->release();
@@ -653,9 +667,9 @@ void Q3DBars::drawScene()
         QMatrix4x4 MVPMatrix;
         if (zComp != 0)
             modelMatrix.translate(0.0f, 0.0f, zComp);
-        modelMatrix.scale(QVector3D(d_ptr->m_rowWidth * d_ptr->m_sceneScale
-                                    , 1.0f
-                                    , d_ptr->m_columnDepth * d_ptr->m_sceneScale));
+        modelMatrix.scale(QVector3D(d_ptr->m_rowWidth * d_ptr->m_sceneScale,
+                                    1.0f,
+                                    d_ptr->m_columnDepth * d_ptr->m_sceneScale));
         modelMatrix.rotate(backgroundRotation, 0.0f, 1.0f, 0.0f);
 
         MVPMatrix = projectionMatrix * viewMatrix * modelMatrix;
@@ -663,26 +677,26 @@ void Q3DBars::drawScene()
         QVector3D backgroundColor = Utils::vectorFromColor(d_ptr->m_theme->m_backgroundColor);
 
         // Set shader bindings
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightP()
-                                                   , lightPos);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->view()
-                                                   , viewMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->model()
-                                                   , modelMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->nModel()
-                                                   , modelMatrix.inverted().transposed());
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->MVP()
-                                                   , MVPMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->color()
-                                                   , backgroundColor);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightS()
-                                                   , d_ptr->m_theme->m_lightStrength);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->ambientS()
-                                                   , d_ptr->m_theme->m_ambientStrength);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightP(),
+                                                   lightPos);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->view(),
+                                                   viewMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->model(),
+                                                   modelMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->nModel(),
+                                                   modelMatrix.inverted().transposed());
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->MVP(),
+                                                   MVPMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->color(),
+                                                   backgroundColor);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightS(),
+                                                   d_ptr->m_theme->m_lightStrength);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->ambientS(),
+                                                   d_ptr->m_theme->m_ambientStrength);
 
         // Draw the object
-        drawObject(d_ptr->m_backgroundShader, d_ptr->m_backgroundObj);
-        //drawObject(d_ptr->m_backgroundShader, d_ptr->m_backgroundObj, true, bgrTexture);
+        d_ptr->m_drawer->drawObject(d_ptr->m_backgroundShader, d_ptr->m_backgroundObj);
+        //d_ptr->m_drawer->drawObject(d_ptr->m_backgroundShader, d_ptr->m_backgroundObj, true, bgrTexture);
     }
 
     // Disable textures
@@ -712,11 +726,12 @@ void Q3DBars::drawScene()
                 continue;
             QMatrix4x4 modelMatrix;
             QMatrix4x4 MVPMatrix;
+            // TODO: Laske rivi- ja sarakelabelien paikat (sijainnit: min-1 ja max+1) ja pistä johonki talteen?
             barPos = (bar + 1) * (d_ptr->m_barSpacing.x());
             rowPos = (row + 1) * (d_ptr->m_barSpacing.y());
-            modelMatrix.translate((d_ptr->m_rowWidth - barPos) / d_ptr->m_scaleFactorX
-                                  , barHeight - 1.0f
-                                  , (d_ptr->m_columnDepth - rowPos) / d_ptr->m_scaleFactorZ + zComp);
+            modelMatrix.translate((d_ptr->m_rowWidth - barPos) / d_ptr->m_scaleFactorX,
+                                  barHeight - 1.0f,
+                                  (d_ptr->m_columnDepth - rowPos) / d_ptr->m_scaleFactorZ + zComp);
             modelMatrix.scale(QVector3D(d_ptr->m_scaleX, barHeight, d_ptr->m_scaleZ));
 
             MVPMatrix = projectionMatrix * viewMatrix * modelMatrix;
@@ -731,8 +746,8 @@ void Q3DBars::drawScene()
 
             float lightStrength = d_ptr->m_theme->m_lightStrength;
             if (d_ptr->m_selectionMode > None) {
-                Q3DBarsPrivate::SelectionType selectionType = d_ptr->isSelected(row, bar
-                                                                                , selection);
+                Q3DBarsPrivate::SelectionType selectionType = d_ptr->isSelected(row, bar,
+                                                                                selection);
                 switch (selectionType) {
                 case Q3DBarsPrivate::Bar:
                 {
@@ -746,8 +761,8 @@ void Q3DBars::drawScene()
                     if (!d_ptr->m_zoomActivated) {
                         d_ptr->m_selectedBar = item;
 #ifdef USE_PAINTER_TEXT
-                        QSize mousePositionAsSize = QSize(d_ptr->m_mousePos.x()
-                                                          , d_ptr->m_mousePos.y());
+                        QSize mousePositionAsSize = QSize(d_ptr->m_mousePos.x(),
+                                                          d_ptr->m_mousePos.y());
                         d_ptr->m_selectedBar->d_ptr->setLabelSize(mousePositionAsSize);
 #else
                         item->d_ptr->setTranslation(modelMatrix.column(3).toVector3D());
@@ -795,16 +810,16 @@ void Q3DBars::drawScene()
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightP(), lightPos);
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->view(), viewMatrix);
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->model(), modelMatrix);
-            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->nModel()
-                                                , modelMatrix.inverted().transposed());
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->nModel(),
+                                                modelMatrix.inverted().transposed());
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->MVP(), MVPMatrix);
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->color(), barColor);
             d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightS(), lightStrength);
-            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->ambientS()
-                                                , d_ptr->m_theme->m_ambientStrength);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->ambientS(),
+                                                d_ptr->m_theme->m_ambientStrength);
 
             // Draw the object
-            drawObject(d_ptr->m_barShader, d_ptr->m_barObj);
+            d_ptr->m_drawer->drawObject(d_ptr->m_barShader, d_ptr->m_barObj);
         }
     }
     if (!barSelectionFound) {
@@ -815,16 +830,16 @@ void Q3DBars::drawScene()
             d_ptr->m_zoomActivated = false;
         }
     } else if (d_ptr->m_selectionMode >= ZoomRow
-             && Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed) {
+               && Q3DBarsPrivate::MouseOnScene == d_ptr->m_mousePressed) {
         // Activate zoom mode
         d_ptr->m_zoomActivated = true;
-        d_ptr->m_sceneViewPort = QRect(0, height() - height() / 5
-                                       , width() / 5, height() / 5);
+        d_ptr->m_sceneViewPort = QRect(0, height() - height() / 5,
+                                       width() / 5, height() / 5);
 
         // Create label textures
         for (int col = 0; col < d_ptr->m_zoomSelection->d_ptr->row().size(); col++) {
             QDataItem *item = d_ptr->m_zoomSelection->d_ptr->getItem(col);
-            generateLabelTexture(item);
+            d_ptr->m_drawer->generateLabelTexture(item);
         }
     } else {
         // Print value of selected bar
@@ -838,11 +853,12 @@ void Q3DBars::drawScene()
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         }
         if (prevItem != d_ptr->m_selectedBar) {
-            generateLabelTexture(d_ptr->m_selectedBar);
+            d_ptr->m_drawer->generateLabelTexture(d_ptr->m_selectedBar);
             prevItem = d_ptr->m_selectedBar;
         }
 
-        drawLabel(*d_ptr->m_selectedBar, viewMatrix, projectionMatrix, true);
+        drawLabel(*d_ptr->m_selectedBar, d_ptr->m_selectedBar->d_ptr->textureId(), viewMatrix,
+                  projectionMatrix, true);
 
         glDisable(GL_TEXTURE_2D);
         if (d_ptr->m_labelTransparency > TransparencyNone)
@@ -858,91 +874,46 @@ void Q3DBars::drawScene()
     d_ptr->m_barShader->release();
 }
 
-// TODO: Move to a separate class, so that it can be used by other vis types as well
-void Q3DBars::drawObject(ShaderHelper *shader, ObjectHelper *object, bool textured
-                         , GLuint textureId)
-{
-    if (textured) {
-        // Activate texture
-        glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, textureId);
-        shader->setUniformValue(shader->texture(), 0);
-    }
-
-    // 1st attribute buffer : vertices
-    glEnableVertexAttribArray(shader->posAtt());
-    glBindBuffer(GL_ARRAY_BUFFER, object->vertexBuf());
-    glVertexAttribPointer(shader->posAtt(), 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-
-    // 2nd attribute buffer : normals
-    glEnableVertexAttribArray(shader->normalAtt());
-    glBindBuffer(GL_ARRAY_BUFFER, object->normalBuf());
-    glVertexAttribPointer(shader->normalAtt(), 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-
-    if (textured) {
-        // 3rd attribute buffer : UVs
-        glEnableVertexAttribArray(shader->uvAtt());
-        glBindBuffer(GL_ARRAY_BUFFER, object->uvBuf());
-        glVertexAttribPointer(shader->uvAtt(), 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-    }
-
-    // Index buffer
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, object->elementBuf());
-
-    // Draw the triangles
-    glDrawElements(GL_TRIANGLES, object->indexCount(), GL_UNSIGNED_SHORT, (void*)0);
-
-    // Free buffers
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
-    if (textured) {
-        glBindTexture(GL_TEXTURE_2D, 0);
-        glDisableVertexAttribArray(shader->uvAtt());
-    }
-    glDisableVertexAttribArray(shader->normalAtt());
-    glDisableVertexAttribArray(shader->posAtt());
-}
-
-// TODO: Move to a separate class, so that it can be used by other vis types as well
-void Q3DBars::generateLabelTexture(QDataItem *item)
-{
-    // Delete previous texture, if there is one
-    GLuint labelTexture = item->d_ptr->textureId();
-    if (labelTexture) {
-        // We have to do this, as we can't know if data is static or not;
-        // texture doesn't change with static data
-        // (basically we could create textures for all bars when data is added, but we
-        // may not need them -> better to do it here dynamically)
-        glDeleteTextures(1, &labelTexture);
-        item->d_ptr->setTextureId(0);
-    }
-
-    // Create labels
-    // Print label into a QImage using QPainter
-    QImage label = Utils::printTextToImage(d_ptr->m_font
-                                           , item->d_ptr->valueStr()
-                                           , d_ptr->m_theme->m_textBackgroundColor
-                                           , d_ptr->m_theme->m_textColor
-                                           , d_ptr->m_labelTransparency);
-
-    // Set label size
-    item->d_ptr->setLabelSize(label.size());
-    // Insert text texture into label
-    item->d_ptr->setTextureId(d_ptr->m_textureHelper->create2DTexture(label, true, true));
-}
-
-// TODO: Move to a separate class, so that it can be used by other vis types as well (will need a lot more parameters..)
-void Q3DBars::drawLabel(const QDataItem &item, const QMatrix4x4 &viewmatrix
-                        , const QMatrix4x4 &projectionmatrix, bool useDepth, qreal rotation) // TODO: Add enum? for label position (below, middle, top etc.)
+void Q3DBars::drawLabel(const QDataItem &item, GLuint textureId, const QMatrix4x4 &viewmatrix,
+                        const QMatrix4x4 &projectionmatrix, bool useDepth, qreal rotation,
+                        Q3DBars::LabelPosition position)
 {
     // Draw label
     QMatrix4x4 modelMatrix;
     QMatrix4x4 MVPMatrix;
     qreal yPosition = -1.5f;
-    if (useDepth) // replace with enum? or adjustable height
+    switch (position) {
+    case Q3DBars::LabelBelow:
+    {
+        yPosition = -1.5f;
+        break;
+    }
+    case Q3DBars::LabelLow:
+    {
+        yPosition = 0.0f;
+        break;
+    }
+    case Q3DBars::LabelMid:
+    {
+        yPosition = item.d_ptr->translation().y();
+        break;
+    }
+    case Q3DBars::LabelHigh:
+    {
+        yPosition = item.d_ptr->translation().y() + (item.d_ptr->value()
+                                                     / d_ptr->m_heightNormalizer) / 2.0f;
+        break;
+    }
+    case Q3DBars::LabelOver:
+    {
         yPosition = item.d_ptr->translation().y()
-                + (item.d_ptr->value() / d_ptr->m_heightNormalizer);
+                + (item.d_ptr->value() / d_ptr->m_heightNormalizer) + 0.1f;
+        if (!useDepth)
+            yPosition -= 0.5f;
+        break;
+    }
+    }
+
     qreal zPosition = zComp;
     qreal xPosition = item.d_ptr->translation().x();
     if (useDepth)
@@ -973,11 +944,10 @@ void Q3DBars::drawLabel(const QDataItem &item, const QMatrix4x4 &viewmatrix
     MVPMatrix = projectionmatrix * viewmatrix * modelMatrix;
 
     // Set shader bindings
-    d_ptr->m_labelShader->setUniformValue(d_ptr->m_labelShader->MVP()
-                                          , MVPMatrix);
+    d_ptr->m_labelShader->setUniformValue(d_ptr->m_labelShader->MVP(), MVPMatrix);
 
     // Draw the object
-    drawObject(d_ptr->m_labelShader, d_ptr->m_labelObj, true, item.d_ptr->textureId());
+    d_ptr->m_drawer->drawObject(d_ptr->m_labelShader, d_ptr->m_labelObj, true, textureId);
 }
 
 void Q3DBars::mousePressEvent(QMouseEvent *event)
@@ -1011,22 +981,22 @@ void Q3DBars::mousePressEvent(QMouseEvent *event)
         d_ptr->m_mousePos = event->pos();
 
         // TODO: testing shaders
-//        if (++shaderNo > 3)
-//            shaderNo = 1;
-//        switch (shaderNo) {
-//        case 1:
-//            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-//                               , QStringLiteral(":/shaders/fragment"));
-//            break;
-//        case 2:
-//            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-//                               , QStringLiteral(":/shaders/fragmentColorOnY"));
-//            break;
-//        case 3:
-//            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-//                               , QStringLiteral(":/shaders/fragmentAmbient"));
-//            break;
-//        }
+        //        if (++shaderNo > 3)
+        //            shaderNo = 1;
+        //        switch (shaderNo) {
+        //        case 1:
+        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
+        //                               , QStringLiteral(":/shaders/fragment"));
+        //            break;
+        //        case 2:
+        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
+        //                               , QStringLiteral(":/shaders/fragmentColorOnY"));
+        //            break;
+        //        case 3:
+        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
+        //                               , QStringLiteral(":/shaders/fragmentAmbient"));
+        //            break;
+        //        }
     }
     CameraHelper::updateMousePos(d_ptr->m_mousePos);
 }
@@ -1050,8 +1020,8 @@ void Q3DBars::mouseMoveEvent(QMouseEvent *event)
     }
 #if 0
     // TODO: Testi - laske kursorin sijainti scenessä
-    QPointF mouse3D((2.0f * event->pos().x() - width()) / height()
-                    , 1.0f - (2.0f * event->pos().y()) / height());
+    QPointF mouse3D((2.0f * event->pos().x() - width()) / height(),
+                    1.0f - (2.0f * event->pos().y()) / height());
     //qDebug() << "mouse position in scene" << mouse3D;
 
     // TODO: Testi laske focal point
@@ -1067,18 +1037,16 @@ void Q3DBars::mouseMoveEvent(QMouseEvent *event)
 
 void Q3DBars::wheelEvent(QWheelEvent *event)
 {
-    if (d_ptr->m_zoomLevel > 100) {
+    if (d_ptr->m_zoomLevel > 100)
         d_ptr->m_zoomLevel += event->angleDelta().y() / 12;
-    } else if (d_ptr->m_zoomLevel > 50) {
+    else if (d_ptr->m_zoomLevel > 50)
         d_ptr->m_zoomLevel += event->angleDelta().y() / 60;
-    } else {
+    else
         d_ptr->m_zoomLevel += event->angleDelta().y() / 120;
-    }
-    if (d_ptr->m_zoomLevel > 500) {
+    if (d_ptr->m_zoomLevel > 500)
         d_ptr->m_zoomLevel = 500;
-    } else if (d_ptr->m_zoomLevel < 10) {
+    else if (d_ptr->m_zoomLevel < 10)
         d_ptr->m_zoomLevel = 10;
-    }
 }
 
 void Q3DBars::resizeEvent(QResizeEvent *event)
@@ -1139,11 +1107,12 @@ void Q3DBars::setMeshFileName(const QString &objFileName)
     d_ptr->m_objFile = objFileName;
 }
 
-void Q3DBars::setupSampleSpace(QPoint sampleCount, const QString &labelRow
-        , const QString &labelColumn, const QString &labelHeight)
+void Q3DBars::setupSampleSpace(QPoint sampleCount, const QString &labelRow,
+                               const QString &labelColumn, const QString &labelHeight)
 {
     d_ptr->m_sampleCount = sampleCount;
     d_ptr->m_dataSet->setLabels(labelRow, labelColumn, labelHeight);
+    // TODO: Generate axis textures and replace qstrings with texture ids in qdataset
     // TODO: Invent "idiotproof" max scene size formula..
     // This seems to work ok if spacing is not negative
     d_ptr->m_maxSceneSize = 2 * qSqrt(sampleCount.x() * sampleCount.y());
@@ -1165,21 +1134,22 @@ void Q3DBars::setCameraPosition(float horizontal, float vertical, int distance)
     d_ptr->m_horizontalRotation = qBound(-180.0f, horizontal, 180.0f);
     d_ptr->m_verticalRotation = qBound(0.0f, vertical, 90.0f);
     d_ptr->m_zoomLevel = qBound(10, distance, 500);
-    CameraHelper::setCameraRotation(QPointF(d_ptr->m_horizontalRotation
-                                            , d_ptr->m_verticalRotation));
+    CameraHelper::setCameraRotation(QPointF(d_ptr->m_horizontalRotation,
+                                            d_ptr->m_verticalRotation));
     qDebug() << "camera rotation set to" << d_ptr->m_horizontalRotation << d_ptr->m_verticalRotation;
 }
 
 void Q3DBars::setTheme(ColorTheme theme)
 {
     d_ptr->m_theme->useTheme(theme);
+    d_ptr->m_drawer->setTheme(*d_ptr->m_theme);
     // Re-initialize shaders
     if (!d_ptr->m_theme->m_uniformColor) {
-        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                           , QStringLiteral(":/shaders/fragmentColorOnY"));
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                           QStringLiteral(":/shaders/fragmentColorOnY"));
     } else {
-        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                           , QStringLiteral(":/shaders/fragment"));
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                           QStringLiteral(":/shaders/fragment"));
     }
 }
 
@@ -1192,11 +1162,11 @@ void Q3DBars::setBarColor(QColor baseColor, QColor heightColor, QColor depthColo
     if (d_ptr->m_theme->m_uniformColor != uniform) {
         // Re-initialize shaders
         if (!d_ptr->m_theme->m_uniformColor) {
-            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                               , QStringLiteral(":/shaders/fragmentColorOnY"));
+            d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                               QStringLiteral(":/shaders/fragmentColorOnY"));
         } else {
-            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-                               , QStringLiteral(":/shaders/fragment"));
+            d_ptr->initShaders(QStringLiteral(":/shaders/vertex"),
+                               QStringLiteral(":/shaders/fragment"));
         }
     }
     d_ptr->m_theme->m_uniformColor = uniform;
@@ -1223,15 +1193,17 @@ void Q3DBars::setFont(const QFont &font)
 {
     d_ptr->m_font = font;
     d_ptr->m_fontSize = font.pointSizeF();
+    d_ptr->m_drawer->setFont(font);
 }
 
 void Q3DBars::setLabelTransparency(LabelTransparency transparency)
 {
     d_ptr->m_labelTransparency = transparency;
+    d_ptr->m_drawer->setTransparency(transparency);
 }
 
-void Q3DBars::addDataRow(const QVector<float> &dataRow, const QString &labelRow
-                         , const QVector<QString> &labelsColumn)
+void Q3DBars::addDataRow(const QVector<float> &dataRow, const QString &labelRow,
+                         const QVector<QString> &labelsColumn)
 {
     // Convert to QDataRow and add to QDataSet
     QDataRow *row = new QDataRow(labelRow);
@@ -1240,13 +1212,13 @@ void Q3DBars::addDataRow(const QVector<float> &dataRow, const QString &labelRow
     row->d_ptr->verifySize(d_ptr->m_sampleCount.x());
     d_ptr->m_dataSet->addRow(row);
     d_ptr->m_heightNormalizer = d_ptr->m_dataSet->d_ptr->highestValue();
-    d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY
-                                    , QVector<QString>(), labelsColumn);
+    d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY,
+                                QVector<QString>(), labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.y());
 }
 
-void Q3DBars::addDataRow(const QVector<QDataItem*> &dataRow, const QString &labelRow
-                         , const QVector<QString> &labelsColumn)
+void Q3DBars::addDataRow(const QVector<QDataItem*> &dataRow, const QString &labelRow,
+                         const QVector<QString> &labelsColumn)
 {
     // Convert to QDataRow and add to QDataSet
     QDataRow *row = new QDataRow(labelRow);
@@ -1255,8 +1227,8 @@ void Q3DBars::addDataRow(const QVector<QDataItem*> &dataRow, const QString &labe
     row->d_ptr->verifySize(d_ptr->m_sampleCount.x());
     d_ptr->m_dataSet->addRow(row);
     d_ptr->m_heightNormalizer = d_ptr->m_dataSet->d_ptr->highestValue();
-    d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY
-                                    , QVector<QString>(), labelsColumn);
+    d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY,
+                                QVector<QString>(), labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.y());
 }
 
@@ -1273,8 +1245,8 @@ void Q3DBars::addDataRow(QDataRow *dataRow)
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.y());
 }
 
-void Q3DBars::addDataSet(const QVector< QVector<float> > &data, const QVector<QString> &labelsRow
-                         , const QVector<QString> &labelsColumn)
+void Q3DBars::addDataSet(const QVector< QVector<float> > &data, const QVector<QString> &labelsRow,
+                         const QVector<QString> &labelsColumn)
 {
     delete d_ptr->m_dataSet;
     d_ptr->m_dataSet = new QDataSet();
@@ -1294,12 +1266,13 @@ void Q3DBars::addDataSet(const QVector< QVector<float> > &data, const QVector<QS
     d_ptr->m_heightNormalizer = d_ptr->m_dataSet->d_ptr->highestValue();
     // Empty QStrings won't override already set axis labels
     d_ptr->m_dataSet->setLabels(QString(), QString(), QString(), labelsRow, labelsColumn);
+    // TODO: generate label textures and replace qstring vectors with texture id (GLuint) vectors
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.y());
 }
 
-void Q3DBars::addDataSet(const QVector< QVector<QDataItem*> > &data
-                         , const QVector<QString> &labelsRow
-                         , const QVector<QString> &labelsColumn)
+void Q3DBars::addDataSet(const QVector< QVector<QDataItem*> > &data,
+                         const QVector<QString> &labelsRow,
+                         const QVector<QString> &labelsColumn)
 {
     delete d_ptr->m_dataSet;
     d_ptr->m_dataSet = new QDataSet();
@@ -1319,6 +1292,7 @@ void Q3DBars::addDataSet(const QVector< QVector<QDataItem*> > &data
     d_ptr->m_heightNormalizer = d_ptr->m_dataSet->d_ptr->highestValue();
     // Empty QStrings won't override already set axis labels
     d_ptr->m_dataSet->setLabels(QString(), QString(), QString(), labelsRow, labelsColumn);
+    // TODO: generate label textures and replace qstring vectors with texture id (GLuint) vectors
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.y());
 }
 
@@ -1331,53 +1305,55 @@ void Q3DBars::addDataSet(QDataSet* dataSet)
     d_ptr->m_dataSet = dataSet;
     // Find highest value
     d_ptr->m_heightNormalizer = d_ptr->m_dataSet->d_ptr->highestValue();
+    // TODO: generate label textures and replace qstring vectors with texture id (GLuint) vectors
 }
 
 Q3DBarsPrivate::Q3DBarsPrivate(Q3DBars *q)
-    : q_ptr(q)
-    , m_paintDevice(0)
-    , m_barShader(0)
-    , m_selectionShader(0)
-    , m_backgroundShader(0)
-    , m_labelShader(0)
-    , m_barObj(0)
-    , m_backgroundObj(0)
-    , m_labelObj(0)
-    , m_sampleCount(QPoint(0, 0))
-    , m_objFile(QStringLiteral(":/defaultMeshes/bar"))
-    , m_mousePressed(MouseNone)
-    , m_mousePos(QPoint(0, 0))
-    , m_zoomLevel(100)
-    , m_horizontalRotation(-45.0f)
-    , m_verticalRotation(15.0f)
-    , m_barThickness(QPointF(0.75f, 0.75f))
-    , m_barSpacing(m_barThickness * 3.0f)
-    , m_heightNormalizer(0.0f)
-    , m_rowWidth(0)
-    , m_columnDepth(0)
-    , m_maxDimension(0)
-    , m_scaleX(0)
-    , m_scaleZ(0)
-    , m_scaleFactorX(0)
-    , m_scaleFactorZ(0)
-    , m_sceneScale(0)
-    , m_maxSceneSize(40.0)
-    , m_theme(new Theme())
-    , m_isInitialized(false)
-    , m_selectionMode(Q3DBars::Bar)
-    , m_selectedBar(0)
-    , m_zoomSelection(0)
-    , m_dataSet(new QDataSet())
-    , m_axisLabelX(QStringLiteral("X"))
-    , m_axisLabelZ(QStringLiteral("Z"))
-    , m_axisLabelY(QStringLiteral("Y"))
-    , m_sceneViewPort(0, 0, q->width(), q->height())
-    , m_zoomViewPort(0, 0, q->width(), q->height())
-    , m_zoomActivated(false)
-    , m_textureHelper(new TextureHelper())
-    , m_labelTransparency(Q3DBars::TransparencyNone)
-    , m_fontSize(10.0f)
-    , m_font(QFont(QStringLiteral("Arial")))
+    : q_ptr(q),
+      m_paintDevice(0),
+      m_barShader(0),
+      m_selectionShader(0),
+      m_backgroundShader(0),
+      m_labelShader(0),
+      m_barObj(0),
+      m_backgroundObj(0),
+      m_labelObj(0),
+      m_sampleCount(QPoint(0, 0)),
+      m_objFile(QStringLiteral(":/defaultMeshes/bar")),
+      m_mousePressed(MouseNone),
+      m_mousePos(QPoint(0, 0)),
+      m_zoomLevel(100),
+      m_horizontalRotation(-45.0f),
+      m_verticalRotation(15.0f),
+      m_barThickness(QPointF(0.75f, 0.75f)),
+      m_barSpacing(m_barThickness * 3.0f),
+      m_heightNormalizer(0.0f),
+      m_rowWidth(0),
+      m_columnDepth(0),
+      m_maxDimension(0),
+      m_scaleX(0),
+      m_scaleZ(0),
+      m_scaleFactorX(0),
+      m_scaleFactorZ(0),
+      m_sceneScale(0),
+      m_maxSceneSize(40.0),
+      m_theme(new Theme()),
+      m_isInitialized(false),
+      m_selectionMode(Q3DBars::Bar),
+      m_selectedBar(0),
+      m_zoomSelection(0),
+      m_dataSet(new QDataSet()),
+      m_axisLabelX(QStringLiteral("X")),
+      m_axisLabelZ(QStringLiteral("Z")),
+      m_axisLabelY(QStringLiteral("Y")),
+      m_sceneViewPort(0, 0, q->width(), q->height()),
+      m_zoomViewPort(0, 0, q->width(), q->height()),
+      m_zoomActivated(false),
+      m_textureHelper(new TextureHelper()),
+      m_labelTransparency(Q3DBars::TransparencyNone),
+      m_fontSize(10.0f),
+      m_font(QFont(QStringLiteral("Arial"))),
+      m_drawer(new Drawer(*m_theme, m_font, m_labelTransparency))
 {
 }
 
@@ -1395,6 +1371,7 @@ Q3DBarsPrivate::~Q3DBarsPrivate()
     delete m_barObj;
     delete m_backgroundObj;
     delete m_textureHelper;
+    delete m_drawer;
 
 #ifndef USE_HAX0R_SELECTION
     q_ptr->glDeleteFramebuffers(1, &m_framebufferSelection);
@@ -1439,8 +1416,8 @@ void Q3DBarsPrivate::initSelectionShader()
 {
     if (m_selectionShader)
         delete m_selectionShader;
-    m_selectionShader = new ShaderHelper(q_ptr, QStringLiteral(":/shaders/vertexSelection")
-                                         , QStringLiteral(":/shaders/fragmentSelection"));
+    m_selectionShader = new ShaderHelper(q_ptr, QStringLiteral(":/shaders/vertexSelection"),
+                                         QStringLiteral(":/shaders/fragmentSelection"));
     m_selectionShader->initialize();
 }
 
@@ -1481,8 +1458,8 @@ void Q3DBarsPrivate::initSelectionBuffer()
 #endif
 }
 
-void Q3DBarsPrivate::initBackgroundShaders(const QString &vertexShader
-                                           , const QString &fragmentShader)
+void Q3DBarsPrivate::initBackgroundShaders(const QString &vertexShader,
+                                           const QString &fragmentShader)
 {
     if (m_backgroundShader)
         delete m_backgroundShader;
@@ -1490,8 +1467,7 @@ void Q3DBarsPrivate::initBackgroundShaders(const QString &vertexShader
     m_backgroundShader->initialize();
 }
 
-void Q3DBarsPrivate::initLabelShaders(const QString &vertexShader
-                                      , const QString &fragmentShader)
+void Q3DBarsPrivate::initLabelShaders(const QString &vertexShader, const QString &fragmentShader)
 {
     if (m_labelShader)
         delete m_labelShader;
@@ -1524,10 +1500,10 @@ Q3DBarsPrivate::SelectionType Q3DBarsPrivate::isSelected(int row, int bar, const
     if (selection == Utils::vectorFromColor(m_theme->m_windowColor))
         return isSelectedType; // skip window
     QVector3D current = QVector3D((GLubyte)(((float)(row + 2) / (float)(m_sampleCount.y() + 2))
-                                            * 255 + 0.49) // add 0.49 to fix rounding
-                                  , (GLubyte)(((float)(bar + 2) / (float)(m_sampleCount.x() + 2))
-                                              * 255 + 0.49) // add 0.49 to fix rounding
-                                  , 0);
+                                            * 255.0),
+                                  (GLubyte)(((float)(bar + 2) / (float)(m_sampleCount.x() + 2))
+                                            * 255.0),
+                                  0);
     if (current == selection)
         isSelectedType = Bar;
     else if (current.y() == selection.y() && (m_selectionMode == Q3DBars::BarAndColumn
diff --git a/src/datavis3d/engine/q3dbars.h b/src/datavis3d/engine/q3dbars.h
index a7b5eeb4..0251a306 100644
--- a/src/datavis3d/engine/q3dbars.h
+++ b/src/datavis3d/engine/q3dbars.h
@@ -53,8 +53,6 @@ class Q3DBarsPrivate;
 class QDataItem;
 class QDataRow;
 class QDataSet;
-class ShaderHelper;
-class ObjectHelper;
 
 class QTCOMMERCIALDATAVIS3D_EXPORT Q3DBars : public Q3DWindow
 {
@@ -116,6 +114,14 @@ public:
         ZoomColumn
     };
 
+    enum LabelPosition {
+        LabelBelow = 0,
+        LabelLow,
+        LabelMid,
+        LabelHigh,
+        LabelOver
+    };
+
 public:
     explicit Q3DBars();
     ~Q3DBars();
@@ -127,37 +133,37 @@ public:
     // Add a row of data. Each new row is added to the front of the sample space, moving previous
     // rows back (if sample space is more than one row deep)
     // TODO: Replace QVector<..> with a data row class (QDataRow)? Move labels to class.
-    void addDataRow(const QVector<float> &dataRow
-                    , const QString &labelRow = QString()
-                    , const QVector<QString> &labelsColumn = QVector<QString>());
+    void addDataRow(const QVector<float> &dataRow,
+                    const QString &labelRow = QString(),
+                    const QVector<QString> &labelsColumn = QVector<QString>());
     // TODO: Replace QVector<..> with a data row class (QDataRow)? Move labels to class.
     // ownership of dataItems is transferred
-    void addDataRow(const QVector<QDataItem*> &dataRow
-                    , const QString &labelRow = QString()
-                    , const QVector<QString> &labelsColumn = QVector<QString>());
+    void addDataRow(const QVector<QDataItem*> &dataRow,
+                    const QString &labelRow = QString(),
+                    const QVector<QString> &labelsColumn = QVector<QString>());
     // ownership of dataRow is transferred
     void addDataRow(QDataRow *dataRow);
 
     // Add complete data set at a time, as a vector of data rows
     // TODO: Replace QVector<QVector<..>> with a data set class (QDataSet)? Move labels to class.
-    void addDataSet(const QVector< QVector<float> > &data
-                    , const QVector<QString> &labelsRow = QVector<QString>()
-                    , const QVector<QString> &labelsColumn = QVector<QString>());
+    void addDataSet(const QVector< QVector<float> > &data,
+                    const QVector<QString> &labelsRow = QVector<QString>(),
+                    const QVector<QString> &labelsColumn = QVector<QString>());
 
     // TODO: Replace QVector<QVector<..>> with a data set class (QDataSet)? Move labels to class.
     // ownership of dataItems is transferred
-    void addDataSet(const QVector< QVector<QDataItem*> > &data
-                    , const QVector<QString> &labelsRow = QVector<QString>()
-                    , const QVector<QString> &labelsColumn = QVector<QString>());
+    void addDataSet(const QVector< QVector<QDataItem*> > &data,
+                    const QVector<QString> &labelsRow = QVector<QString>(),
+                    const QVector<QString> &labelsColumn = QVector<QString>());
     // ownership of dataSet is transferred
     void addDataSet(QDataSet* dataSet);
 
     // bar thickness, spacing between bars, and is spacing relative to thickness or absolute
     // y -component sets the thickness/spacing of z -direction
     // With relative 0.0f means side-to-side, 1.0f = one thickness in between
-    void setBarSpecs(QPointF thickness = QPointF(1.0f, 1.0f)
-            , QPointF spacing = QPointF(1.0f, 1.0f)
-            , bool relative = true);
+    void setBarSpecs(QPointF thickness = QPointF(1.0f, 1.0f),
+                     QPointF spacing = QPointF(1.0f, 1.0f),
+                     bool relative = true);
 
     // bar type; bars (=cubes), pyramids, cones, cylinders, etc.
     void setBarType(BarStyle style, bool smooth = false);
@@ -166,8 +172,9 @@ public:
     void setMeshFileName(const QString &objFileName);
 
     // how many samples per row and column, and names for axes
-    void setupSampleSpace(QPoint sampleCount, const QString &labelRow = QString()
-            , const QString &labelColumn = QString(), const QString &labelHeight = QString());
+    void setupSampleSpace(QPoint sampleCount, const QString &labelRow = QString(),
+                          const QString &labelColumn = QString(),
+                          const QString &labelHeight = QString());
 
     // Select preset camera placement
     void setCameraPreset(CameraPreset preset);
@@ -208,12 +215,9 @@ protected:
 private:
     void drawZoomScene();
     void drawScene();
-    void drawLabel(const QDataItem &item, const QMatrix4x4 &viewmatrix
-                   , const QMatrix4x4 &projectionmatrix, bool useDepth = false
-            , qreal rotation = 0.0f);
-    void drawObject(ShaderHelper *shader, ObjectHelper *object, bool textured = false
-            , GLuint textureId = 0);
-    void generateLabelTexture(QDataItem *item);
+    void drawLabel(const QDataItem &item, GLuint textureId, const QMatrix4x4 &viewmatrix,
+                   const QMatrix4x4 &projectionmatrix, bool useDepth = false,
+                   qreal rotation = 0.0f, Q3DBars::LabelPosition position = Q3DBars::LabelOver);
     QScopedPointer<Q3DBarsPrivate> d_ptr;
     Q_DISABLE_COPY(Q3DBars)
 };
diff --git a/src/datavis3d/engine/q3dbars_p.h b/src/datavis3d/engine/q3dbars_p.h
index 4e70eb2b..675c553f 100644
--- a/src/datavis3d/engine/q3dbars_p.h
+++ b/src/datavis3d/engine/q3dbars_p.h
@@ -70,6 +70,7 @@ class ShaderHelper;
 class ObjectHelper;
 class TextureHelper;
 class Theme;
+class Drawer;
 
 class Q3DBarsPrivate
 {
@@ -151,6 +152,7 @@ public:
     Q3DBars::LabelTransparency m_labelTransparency;
     float m_fontSize;
     QFont m_font;
+    Drawer *m_drawer;
 };
 
 QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/q3dwindow.cpp b/src/datavis3d/engine/q3dwindow.cpp
index 56a457b3..bb158226 100644
--- a/src/datavis3d/engine/q3dwindow.cpp
+++ b/src/datavis3d/engine/q3dwindow.cpp
@@ -53,8 +53,8 @@
 QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
 
 Q3DWindow::Q3DWindow(QWindow *parent)
-    : QWindow(parent)
-    , d_ptr(new Q3DWindowPrivate(this))
+    : QWindow(parent),
+      d_ptr(new Q3DWindowPrivate(this))
 {
     setSurfaceType(QWindow::OpenGLSurface);
     QSurfaceFormat surfaceFormat;
@@ -177,11 +177,11 @@ QOpenGLPaintDevice *Q3DWindow::getDevice()
 }
 
 Q3DWindowPrivate::Q3DWindowPrivate(Q3DWindow *q)
-    : q_ptr(q)
-    , m_updatePending(false)
-    , m_animating(false)
-    , m_context(new QOpenGLContext(q))
-    , m_device(0)
+    : q_ptr(q),
+      m_updatePending(false),
+      m_animating(false),
+      m_context(new QOpenGLContext(q)),
+      m_device(0)
 {
 }
 
diff --git a/src/datavis3d/engine/qdataitem.cpp b/src/datavis3d/engine/qdataitem.cpp
index 28a96cc0..f658b0ba 100644
--- a/src/datavis3d/engine/qdataitem.cpp
+++ b/src/datavis3d/engine/qdataitem.cpp
@@ -70,13 +70,13 @@ void QDataItem::setValue(float value)
 }
 
 QDataItemPrivate::QDataItemPrivate(QDataItem *q, float value, const QString &label)
-    : q_ptr(q)
-    , m_value(value)
-    , m_label(label)
-    , m_prependLabel(false)
-    , m_size(QSize(0, 0))
-    , m_translation(QVector3D(0, 0, 0))
-    , m_textureId(0)
+    : q_ptr(q),
+      m_value(value),
+      m_label(label),
+      m_prependLabel(false),
+      m_size(QSize(0, 0)),
+      m_translation(QVector3D(0, 0, 0)),
+      m_textureId(0)
 {
 }
 
diff --git a/src/datavis3d/engine/qdataitem.h b/src/datavis3d/engine/qdataitem.h
index 1b9ec9e7..36d325ad 100644
--- a/src/datavis3d/engine/qdataitem.h
+++ b/src/datavis3d/engine/qdataitem.h
@@ -64,6 +64,7 @@ private:
     friend class Q3DBars;
     friend class Q3DBarsPrivate;
     friend class QDataRowPrivate;
+    friend class Drawer;
 };
 
 QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/qdataitem_p.h b/src/datavis3d/engine/qdataitem_p.h
index 55bb623e..77282e86 100644
--- a/src/datavis3d/engine/qdataitem_p.h
+++ b/src/datavis3d/engine/qdataitem_p.h
@@ -64,8 +64,8 @@ QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
 class QDataItemPrivate
 {
     public:
-    explicit QDataItemPrivate(QDataItem *q, float value = 0.0f
-            , const QString &label = QString());
+    explicit QDataItemPrivate(QDataItem *q, float value = 0.0f,
+                              const QString &label = QString());
     ~QDataItemPrivate();
 
     void setLabelSize(const QSize &size);
diff --git a/src/datavis3d/engine/qdatarow.cpp b/src/datavis3d/engine/qdatarow.cpp
index 937c7b0b..2146aabe 100644
--- a/src/datavis3d/engine/qdatarow.cpp
+++ b/src/datavis3d/engine/qdatarow.cpp
@@ -70,8 +70,8 @@ void QDataRow::addItem(QDataItem *item)
 }
 
 QDataRowPrivate::QDataRowPrivate(QDataRow *q, const QString &label)
-    : q_ptr(q)
-    , m_label(label)
+    : q_ptr(q),
+      m_label(label)
 {
 }
 
diff --git a/src/datavis3d/engine/qdataset.cpp b/src/datavis3d/engine/qdataset.cpp
index ddfd907c..08e129ff 100644
--- a/src/datavis3d/engine/qdataset.cpp
+++ b/src/datavis3d/engine/qdataset.cpp
@@ -60,11 +60,11 @@ QDataSet::~QDataSet()
     //qDebug("~QDataSet");
 }
 
-void QDataSet::setLabels(const QString &xAxis
-                         , const QString &zAxis
-                         , const QString &yAxis
-                         , const QVector<QString> &labelsRow
-                         , const QVector<QString> &labelsColumn)
+void QDataSet::setLabels(const QString &xAxis,
+                         const QString &zAxis,
+                         const QString &yAxis,
+                         const QVector<QString> &labelsRow,
+                         const QVector<QString> &labelsColumn)
 {
     QString empty;
     // skip empty labels, keep the previous ones
@@ -84,13 +84,13 @@ void QDataSet::addRow(QDataRow *row)
 }
 
 QDataSetPrivate::QDataSetPrivate(QDataSet *q)
-    : q_ptr(q)
-    , m_set(QVector<QDataRow*>())
-    , m_xAxis(QString())
-    , m_zAxis(QString())
-    , m_yAxis(QString())
-    , m_labelsRow(QVector<QString>())
-    , m_labelsColumn(QVector<QString>())
+    : q_ptr(q),
+      m_set(QVector<QDataRow*>()),
+      m_xAxis(QString()),
+      m_zAxis(QString()),
+      m_yAxis(QString()),
+      m_labelsRow(QVector<QString>()),
+      m_labelsColumn(QVector<QString>())
 {
 }
 
diff --git a/src/datavis3d/engine/qdataset.h b/src/datavis3d/engine/qdataset.h
index 589cb9cd..57d06e2b 100644
--- a/src/datavis3d/engine/qdataset.h
+++ b/src/datavis3d/engine/qdataset.h
@@ -60,11 +60,11 @@ public:
     explicit QDataSet();
     ~QDataSet();
 
-    void setLabels(const QString &xAxis = QString()
-            , const QString &zAxis = QString()
-            , const QString &yAxis = QString()
-            , const QVector<QString> &labelsRow = QVector<QString>()
-            , const QVector<QString> &labelsColumn = QVector<QString>());
+    void setLabels(const QString &xAxis = QString(),
+                   const QString &zAxis = QString(),
+                   const QString &yAxis = QString(),
+                   const QVector<QString> &labelsRow = QVector<QString>(),
+                   const QVector<QString> &labelsColumn = QVector<QString>());
     void addRow(QDataRow *row);
 
 private:
diff --git a/src/datavis3d/engine/theme.cpp b/src/datavis3d/engine/theme.cpp
index 62d1651b..30c2393b 100644
--- a/src/datavis3d/engine/theme.cpp
+++ b/src/datavis3d/engine/theme.cpp
@@ -49,20 +49,20 @@
 QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
 
 Theme::Theme()
-    : m_baseColor(QColor(Qt::gray))
-    , m_heightColor(QColor(Qt::white))
-    , m_depthColor(QColor(Qt::darkGray))
-    , m_backgroundColor(QColor(Qt::gray))
-    , m_windowColor(QColor(Qt::gray))
-    , m_textColor(QColor(Qt::white))
-    , m_textBackgroundColor(QColor(0x00, 0x00, 0x00, 0x80))
-    , m_highlightBarColor(QColor(Qt::red))
-    , m_highlightRowColor(QColor(Qt::darkRed))
-    , m_highlightColumnColor(QColor(Qt::darkMagenta))
-    , m_lightStrength(4.0f)
-    , m_ambientStrength(0.3f)
-    , m_highlightLightStrength(8.0f)
-    , m_uniformColor(true)
+    : m_baseColor(QColor(Qt::gray)),
+      m_heightColor(QColor(Qt::white)),
+      m_depthColor(QColor(Qt::darkGray)),
+      m_backgroundColor(QColor(Qt::gray)),
+      m_windowColor(QColor(Qt::gray)),
+      m_textColor(QColor(Qt::white)),
+      m_textBackgroundColor(QColor(0x00, 0x00, 0x00, 0x80)),
+      m_highlightBarColor(QColor(Qt::red)),
+      m_highlightRowColor(QColor(Qt::darkRed)),
+      m_highlightColumnColor(QColor(Qt::darkMagenta)),
+      m_lightStrength(4.0f),
+      m_ambientStrength(0.3f),
+      m_highlightLightStrength(8.0f),
+      m_uniformColor(true)
 {
 }
 
diff --git a/src/datavis3d/engine/theme_p.h b/src/datavis3d/engine/theme_p.h
index 2bd5ed5f..9e77cf75 100644
--- a/src/datavis3d/engine/theme_p.h
+++ b/src/datavis3d/engine/theme_p.h
@@ -70,6 +70,7 @@ public:
 private:
     friend class Q3DBars;
     friend class Q3DBarsPrivate;
+    friend class Drawer;
 
     QColor m_baseColor;
     QColor m_heightColor;