Replace 'chart' with 'graph'

Task-number: QTRD-2369

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

10 files changed, 842 insertions, 81 deletions

diff --git a/tests/barstest/chart.cpp b/tests/barstest/chart.cpp
index cd41a6be..c1599b18 100644
--- a/tests/barstest/chart.cpp
+++ b/tests/barstest/chart.cpp
@@ -26,7 +26,7 @@ QT_DATAVISUALIZATION_USE_NAMESPACE
 
 const QString celsiusString = QString(QChar(0xB0)) + "C";
 
-ChartModifier::ChartModifier(Q3DBars *barchart)
+GraphModifier::GraphModifier(Q3DBars *barchart)
     : m_chart(barchart),
       m_columnCount(21),
       m_rowCount(21),
@@ -117,17 +117,17 @@ ChartModifier::ChartModifier(Q3DBars *barchart)
     resetTemperatureData();
 }
 
-ChartModifier::~ChartModifier()
+GraphModifier::~GraphModifier()
 {
     delete m_chart;
 }
 
-void ChartModifier::start()
+void GraphModifier::start()
 {
     restart(false);
 }
 
-void ChartModifier::restart(bool dynamicData)
+void GraphModifier::restart(bool dynamicData)
 {
     m_static = !dynamicData;
 
@@ -154,7 +154,7 @@ void ChartModifier::restart(bool dynamicData)
     }
 }
 
-void ChartModifier::selectBar()
+void GraphModifier::selectBar()
 {
     QPoint targetBar(5, 5);
     QPoint noSelection(-1, -1);
@@ -164,7 +164,7 @@ void ChartModifier::selectBar()
         m_chart->setSelectedBarPos(noSelection);
 }
 
-void ChartModifier::swapAxis()
+void GraphModifier::swapAxis()
 {
     static int counter = 0;
     int state = ++counter % 3;
@@ -183,7 +183,7 @@ void ChartModifier::swapAxis()
     m_chart->setValueAxis(m_currentAxis);
 }
 
-void ChartModifier::releaseAxes()
+void GraphModifier::releaseAxes()
 {
     // Releases all axes - results in default axes for all dimensions.
     // Axes reset when the graph is switched as set*Axis calls are made, which
@@ -197,7 +197,7 @@ void ChartModifier::releaseAxes()
     m_chart->releaseAxis(m_genericColumnAxis);
 }
 
-void ChartModifier::releaseProxies()
+void GraphModifier::releaseProxies()
 {
     // Releases all proxies - results in default proxy.
     // Proxies will get readded back when graph is switched as setDataProxy call is made.
@@ -205,7 +205,7 @@ void ChartModifier::releaseProxies()
     m_chart->releaseDataProxy(m_genericData);
 }
 
-void ChartModifier::createMassiveArray()
+void GraphModifier::createMassiveArray()
 {
     const int arrayDimension = 1000;
     QTime timer;
@@ -241,7 +241,7 @@ void ChartModifier::createMassiveArray()
     qDebug() << "Created Massive Array (" << arrayDimension << "), time:" << timer.elapsed();
 }
 
-void ChartModifier::resetTemperatureData()
+void GraphModifier::resetTemperatureData()
 {
 
     // Set up data
@@ -281,7 +281,7 @@ static int addCounter = 0;
 static int insertCounter = 0;
 static int changeCounter = 0;
 
-void ChartModifier::addRow()
+void GraphModifier::addRow()
 {
     QBarDataRow *dataRow = new QBarDataRow(m_columnCount);
     for (qreal i = 0; i < m_columnCount; i++)
@@ -292,7 +292,7 @@ void ChartModifier::addRow()
     m_chart->activeDataProxy()->addRow(dataRow, label);
 }
 
-void ChartModifier::addRows()
+void GraphModifier::addRows()
 {
     QBarDataArray dataArray;
     QStringList labels;
@@ -308,7 +308,7 @@ void ChartModifier::addRows()
     m_chart->activeDataProxy()->addRows(dataArray, labels);
 }
 
-void ChartModifier::insertRow()
+void GraphModifier::insertRow()
 {
     QBarDataRow *dataRow = new QBarDataRow(m_columnCount);
     for (qreal i = 0; i < m_columnCount; i++)
@@ -320,7 +320,7 @@ void ChartModifier::insertRow()
     m_chart->activeDataProxy()->insertRow(row, dataRow, label);
 }
 
-void ChartModifier::insertRows()
+void GraphModifier::insertRows()
 {
     QTime timer;
     timer.start();
@@ -340,7 +340,7 @@ void ChartModifier::insertRows()
     qDebug() << "Inserted" << m_rowCount << "rows, time:" << timer.elapsed();
 }
 
-void ChartModifier::changeItem()
+void GraphModifier::changeItem()
 {
     // TODO Needs to be changed to account for data window offset once it is implemented.
     int row = m_selectedBarPos.x();
@@ -351,7 +351,7 @@ void ChartModifier::changeItem()
     }
 }
 
-void ChartModifier::changeRow()
+void GraphModifier::changeRow()
 {
     // TODO Needs to be changed to account for data window offset once it is implemented.
     int row = m_selectedBarPos.x();
@@ -364,7 +364,7 @@ void ChartModifier::changeRow()
     }
 }
 
-void ChartModifier::changeRows()
+void GraphModifier::changeRows()
 {
     // TODO Needs to be changed to account for data window offset once it is implemented.
     int row = m_selectedBarPos.x();
@@ -383,7 +383,7 @@ void ChartModifier::changeRows()
     }
 }
 
-void ChartModifier::removeRow()
+void GraphModifier::removeRow()
 {
     // TODO Needs to be changed to account for data window offset once it is implemented.
     int row = m_selectedBarPos.x();
@@ -391,7 +391,7 @@ void ChartModifier::removeRow()
         m_chart->activeDataProxy()->removeRows(row, 1);
 }
 
-void ChartModifier::removeRows()
+void GraphModifier::removeRows()
 {
     // TODO Needs to be changed to account for data window offset once it is implemented.
     int row = m_selectedBarPos.x();
@@ -401,7 +401,7 @@ void ChartModifier::removeRows()
     }
 }
 
-void ChartModifier::changeStyle()
+void GraphModifier::changeStyle()
 {
     static int model = 0;
     switch (model) {
@@ -441,7 +441,7 @@ void ChartModifier::changeStyle()
         model = 0;
 }
 
-void ChartModifier::changePresetCamera()
+void GraphModifier::changePresetCamera()
 {
     static int preset = QDataVis::CameraPresetFrontLow;
 
@@ -451,7 +451,7 @@ void ChartModifier::changePresetCamera()
         preset = QDataVis::CameraPresetFrontLow;
 }
 
-void ChartModifier::changeTheme()
+void GraphModifier::changeTheme()
 {
     static int theme = QDataVis::ThemeQt;
 
@@ -461,7 +461,7 @@ void ChartModifier::changeTheme()
         theme = QDataVis::ThemeQt;
 }
 
-void ChartModifier::changeLabelStyle()
+void GraphModifier::changeLabelStyle()
 {
     static int style = QDataVis::LabelStyleOpaque;
 
@@ -471,7 +471,7 @@ void ChartModifier::changeLabelStyle()
         style = QDataVis::LabelStyleOpaque;
 }
 
-void ChartModifier::changeSelectionMode()
+void GraphModifier::changeSelectionMode()
 {
     static int selectionMode = m_chart->selectionMode();
 
@@ -481,14 +481,14 @@ void ChartModifier::changeSelectionMode()
     m_chart->setSelectionMode((QDataVis::SelectionMode)selectionMode);
 }
 
-void ChartModifier::changeFont(const QFont &font)
+void GraphModifier::changeFont(const QFont &font)
 {
     QFont newFont = font;
     newFont.setPointSize(m_fontSize);
     m_chart->setFont(newFont);
 }
 
-void ChartModifier::changeFontSize(int fontsize)
+void GraphModifier::changeFontSize(int fontsize)
 {
     m_fontSize = fontsize;
     QFont font = m_chart->font();
@@ -496,83 +496,83 @@ void ChartModifier::changeFontSize(int fontsize)
     m_chart->setFont(font);
 }
 
-void ChartModifier::shadowQualityUpdatedByVisual(QDataVis::ShadowQuality sq)
+void GraphModifier::shadowQualityUpdatedByVisual(QDataVis::ShadowQuality sq)
 {
     int quality = int(sq);
     // Updates the UI component to show correct shadow quality
     emit shadowQualityChanged(quality);
 }
 
-void ChartModifier::handleSelectionChange(const QPoint &position)
+void GraphModifier::handleSelectionChange(const QPoint &position)
 {
     m_selectedBarPos = position;
     qDebug() << "Selected bar position:" << position;
 }
 
-void ChartModifier::changeShadowQuality(int quality)
+void GraphModifier::changeShadowQuality(int quality)
 {
     QDataVis::ShadowQuality sq = QDataVis::ShadowQuality(quality);
     m_chart->setShadowQuality(sq);
     emit shadowQualityChanged(quality);
 }
 
-void ChartModifier::setBackgroundEnabled(int enabled)
+void GraphModifier::setBackgroundEnabled(int enabled)
 {
     m_chart->setBackgroundVisible((bool)enabled);
 }
 
-void ChartModifier::setGridEnabled(int enabled)
+void GraphModifier::setGridEnabled(int enabled)
 {
     m_chart->setGridVisible((bool)enabled);
 }
 
-void ChartModifier::rotateX(int rotation)
+void GraphModifier::rotateX(int rotation)
 {
     m_xRotation = rotation;
     m_chart->setCameraPosition(m_xRotation, m_yRotation);
 }
 
-void ChartModifier::rotateY(int rotation)
+void GraphModifier::rotateY(int rotation)
 {
     m_yRotation = rotation;
     m_chart->setCameraPosition(m_xRotation, m_yRotation);
 }
 
-void ChartModifier::setSpecsRatio(int barwidth)
+void GraphModifier::setSpecsRatio(int barwidth)
 {
     m_chart->setBarThickness((qreal)barwidth / 30.0);
 }
 
-void ChartModifier::setSpacingSpecsX(int spacing)
+void GraphModifier::setSpacingSpecsX(int spacing)
 {
     m_barSpacingX = (qreal)spacing / 100.0;
     m_chart->setBarSpacing(QSizeF(m_barSpacingX, m_barSpacingZ));
 }
 
-void ChartModifier::setSpacingSpecsZ(int spacing)
+void GraphModifier::setSpacingSpecsZ(int spacing)
 {
     m_barSpacingZ = (qreal)spacing / 100.0;
     m_chart->setBarSpacing(QSizeF(m_barSpacingX, m_barSpacingZ));
 }
 
-void ChartModifier::setSampleCountX(int samples)
+void GraphModifier::setSampleCountX(int samples)
 {
     m_columnCount = samples;
     m_genericColumnAxis->setRange(m_genericRowAxis->min(), m_genericRowAxis->min() + samples - 1);
 }
 
-void ChartModifier::setSampleCountZ(int samples)
+void GraphModifier::setSampleCountZ(int samples)
 {
     m_rowCount = samples;
     m_genericRowAxis->setRange(m_genericColumnAxis->min(), m_genericColumnAxis->min() + samples - 1);
 }
 
-void ChartModifier::setMinX(int min)
+void GraphModifier::setMinX(int min)
 {
     m_genericRowAxis->setRange(min, min + m_rowCount - 1);
 }
 
-void ChartModifier::setMinZ(int min)
+void GraphModifier::setMinZ(int min)
 {
     m_genericColumnAxis->setRange(min, min + m_rowCount - 1);
 }
diff --git a/tests/barstest/chart.h b/tests/barstest/chart.h
index a2538b1c..e4e96ffb 100644
--- a/tests/barstest/chart.h
+++ b/tests/barstest/chart.h
@@ -28,12 +28,12 @@
 
 using namespace QtDataVisualization;
 
-class ChartModifier : public QObject
+class GraphModifier : public QObject
 {
     Q_OBJECT
 public:
-    explicit ChartModifier(Q3DBars *barchart);
-    ~ChartModifier();
+    explicit GraphModifier(Q3DBars *barchart);
+    ~GraphModifier();
 
     void resetTemperatureData();
     void addRow();
diff --git a/tests/barstest/main.cpp b/tests/barstest/main.cpp
index ca98688c..850561a7 100644
--- a/tests/barstest/main.cpp
+++ b/tests/barstest/main.cpp
@@ -260,73 +260,73 @@ int main(int argc, char **argv)
 
     widget->show();
 
-    ChartModifier *modifier = new ChartModifier(widgetchart);
+    GraphModifier *modifier = new GraphModifier(widgetchart);
 
-    QObject::connect(rotationSliderX, &QSlider::valueChanged, modifier, &ChartModifier::rotateX);
-    QObject::connect(rotationSliderY, &QSlider::valueChanged, modifier, &ChartModifier::rotateY);
+    QObject::connect(rotationSliderX, &QSlider::valueChanged, modifier, &GraphModifier::rotateX);
+    QObject::connect(rotationSliderY, &QSlider::valueChanged, modifier, &GraphModifier::rotateY);
 
-    QObject::connect(ratioSlider, &QSlider::valueChanged, modifier, &ChartModifier::setSpecsRatio);
+    QObject::connect(ratioSlider, &QSlider::valueChanged, modifier, &GraphModifier::setSpecsRatio);
 
     QObject::connect(spacingSliderX, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setSpacingSpecsX);
+                     &GraphModifier::setSpacingSpecsX);
     QObject::connect(spacingSliderZ, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setSpacingSpecsZ);
+                     &GraphModifier::setSpacingSpecsZ);
 
     QObject::connect(sampleSliderX, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setSampleCountX);
+                     &GraphModifier::setSampleCountX);
     QObject::connect(sampleSliderZ, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setSampleCountZ);
+                     &GraphModifier::setSampleCountZ);
     QObject::connect(minSliderX, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setMinX);
+                     &GraphModifier::setMinX);
     QObject::connect(minSliderZ, &QSlider::valueChanged, modifier,
-                     &ChartModifier::setMinZ);
+                     &GraphModifier::setMinZ);
 
     QObject::connect(shadowQuality, SIGNAL(currentIndexChanged(int)), modifier,
                      SLOT(changeShadowQuality(int)));
-    QObject::connect(modifier, &ChartModifier::shadowQualityChanged, shadowQuality,
+    QObject::connect(modifier, &GraphModifier::shadowQualityChanged, shadowQuality,
                      &QComboBox::setCurrentIndex);
     QObject::connect(widgetchart, &Q3DBars::shadowQualityChanged, modifier,
-                     &ChartModifier::shadowQualityUpdatedByVisual);
+                     &GraphModifier::shadowQualityUpdatedByVisual);
     QObject::connect(widgetchart, &Q3DBars::selectedBarPosChanged, modifier,
-                     &ChartModifier::handleSelectionChange);
+                     &GraphModifier::handleSelectionChange);
 
     QObject::connect(fontSizeSlider, &QSlider::valueChanged, modifier,
-                     &ChartModifier::changeFontSize);
+                     &GraphModifier::changeFontSize);
 
-    QObject::connect(styleButton, &QPushButton::clicked, modifier, &ChartModifier::changeStyle);
+    QObject::connect(styleButton, &QPushButton::clicked, modifier, &GraphModifier::changeStyle);
     QObject::connect(cameraButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::changePresetCamera);
-    QObject::connect(themeButton, &QPushButton::clicked, modifier, &ChartModifier::changeTheme);
+                     &GraphModifier::changePresetCamera);
+    QObject::connect(themeButton, &QPushButton::clicked, modifier, &GraphModifier::changeTheme);
     QObject::connect(labelButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::changeStyle);
-    QObject::connect(addDataButton, &QPushButton::clicked, modifier, &ChartModifier::addRow);
-    QObject::connect(addMultiDataButton, &QPushButton::clicked, modifier, &ChartModifier::addRows);
-    QObject::connect(insertDataButton, &QPushButton::clicked, modifier, &ChartModifier::insertRow);
-    QObject::connect(insertMultiDataButton, &QPushButton::clicked, modifier, &ChartModifier::insertRows);
-    QObject::connect(changeSingleDataButton, &QPushButton::clicked, modifier, &ChartModifier::changeItem);
-    QObject::connect(changeRowButton, &QPushButton::clicked, modifier, &ChartModifier::changeRow);
-    QObject::connect(changeRowsButton, &QPushButton::clicked, modifier, &ChartModifier::changeRows);
-    QObject::connect(removeRowButton, &QPushButton::clicked, modifier, &ChartModifier::removeRow);
-    QObject::connect(removeRowsButton, &QPushButton::clicked, modifier, &ChartModifier::removeRows);
-    QObject::connect(massiveArrayButton, &QPushButton::clicked, modifier, &ChartModifier::createMassiveArray);
+                     &GraphModifier::changeStyle);
+    QObject::connect(addDataButton, &QPushButton::clicked, modifier, &GraphModifier::addRow);
+    QObject::connect(addMultiDataButton, &QPushButton::clicked, modifier, &GraphModifier::addRows);
+    QObject::connect(insertDataButton, &QPushButton::clicked, modifier, &GraphModifier::insertRow);
+    QObject::connect(insertMultiDataButton, &QPushButton::clicked, modifier, &GraphModifier::insertRows);
+    QObject::connect(changeSingleDataButton, &QPushButton::clicked, modifier, &GraphModifier::changeItem);
+    QObject::connect(changeRowButton, &QPushButton::clicked, modifier, &GraphModifier::changeRow);
+    QObject::connect(changeRowsButton, &QPushButton::clicked, modifier, &GraphModifier::changeRows);
+    QObject::connect(removeRowButton, &QPushButton::clicked, modifier, &GraphModifier::removeRow);
+    QObject::connect(removeRowsButton, &QPushButton::clicked, modifier, &GraphModifier::removeRows);
+    QObject::connect(massiveArrayButton, &QPushButton::clicked, modifier, &GraphModifier::createMassiveArray);
     QObject::connect(selectionButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::changeSelectionMode);
+                     &GraphModifier::changeSelectionMode);
     QObject::connect(setSelectedBarButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::selectBar);
+                     &GraphModifier::selectBar);
     QObject::connect(swapAxisButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::swapAxis);
+                     &GraphModifier::swapAxis);
     QObject::connect(releaseAxesButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::releaseAxes);
+                     &GraphModifier::releaseAxes);
     QObject::connect(releaseProxiesButton, &QPushButton::clicked, modifier,
-                     &ChartModifier::releaseProxies);
+                     &GraphModifier::releaseProxies);
 
     QObject::connect(fontList, &QFontComboBox::currentFontChanged, modifier,
-                     &ChartModifier::changeFont);
+                     &GraphModifier::changeFont);
 
     QObject::connect(backgroundCheckBox, &QCheckBox::stateChanged, modifier,
-                     &ChartModifier::setBackgroundEnabled);
+                     &GraphModifier::setBackgroundEnabled);
     QObject::connect(gridCheckBox, &QCheckBox::stateChanged, modifier,
-                     &ChartModifier::setGridEnabled);
+                     &GraphModifier::setGridEnabled);
 
     QObject::connect(rotationCheckBox, &QCheckBox::stateChanged, rotationSliderX,
                      &QSlider::setEnabled);
@@ -367,7 +367,7 @@ int main(int argc, char **argv)
                      &QSlider::setEnabled);
     QObject::connect(staticCheckBox, &QCheckBox::stateChanged, swapAxisButton,
                      &QSlider::setEnabled);
-    QObject::connect(staticCheckBox, &QCheckBox::stateChanged, modifier, &ChartModifier::restart);
+    QObject::connect(staticCheckBox, &QCheckBox::stateChanged, modifier, &GraphModifier::restart);
 
     modifier->start();
 
diff --git a/tests/surfacetest/Heightmap.png b/tests/surfacetest/Heightmap.png
new file mode 100644
index 00000000..2a860111
--- /dev/null
+++ b/tests/surfacetest/Heightmap.png
diff --git a/tests/surfacetest/graphmodifier.cpp b/tests/surfacetest/graphmodifier.cpp
new file mode 100644
index 00000000..d4e99031
--- /dev/null
+++ b/tests/surfacetest/graphmodifier.cpp
@@ -0,0 +1,388 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the QtDataVisualization module.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+**
+****************************************************************************/
+
+#include "graphmodifier.h"
+#include <QtDataVisualization/Q3DValueAxis>
+#include <QtDataVisualization/QSurfaceDataProxy>
+
+#include <qmath.h>
+#include <QLinearGradient>
+#include <QDebug>
+
+QT_DATAVISUALIZATION_USE_NAMESPACE
+
+//#define JITTER_PLANE
+//#define WONKY_PLANE
+
+GraphModifier::GraphModifier(Q3DSurface *graph)
+    : m_graph(graph),
+      m_gridSliderX(0),
+      m_gridSliderZ(0),
+      m_axisRangeSliderX(0),
+      m_axisRangeSliderZ(0),
+      m_axisMinSliderX(0),
+      m_axisMinSliderZ(0),
+      m_xCount(50),
+      m_zCount(50),
+      m_activeSample(0),
+      m_fontSize(40),
+      m_rangeX(16.0),
+      m_rangeZ(16.0),
+      m_minX(-8.0),
+      m_minZ(-8.0),
+      m_planeArray(0)
+{
+    m_graph->setAxisX(new Q3DValueAxis);
+    m_graph->setAxisY(new Q3DValueAxis);
+    m_graph->setAxisZ(new Q3DValueAxis);
+    m_graph->axisX()->setRange(m_minX, m_minX + m_rangeX);
+    m_graph->axisZ()->setRange(m_minZ, m_minZ + m_rangeZ);
+    changeStyle();
+
+    connect(&m_timer, &QTimer::timeout, this, &GraphModifier::timeout);
+}
+
+GraphModifier::~GraphModifier()
+{
+    delete m_graph;
+}
+
+void GraphModifier::toggleSmooth(bool enabled)
+{
+    qDebug() << "GraphModifier::toggleSmooth " << enabled;
+    m_graph->setSmoothSurfaceEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGrid(bool enable)
+{
+    qDebug() << "GraphModifier::toggleSurfaceGrid" << enable;
+    m_graph->setSurfaceGridEnabled(enable);
+}
+
+void GraphModifier::toggleSqrtSin(bool enable)
+{
+    if (enable) {
+        qDebug() << "Create Sqrt&Sin surface, (" << m_xCount << ", " << m_zCount << ")";
+
+        float minX = -10.0;
+        float maxX = 10.0;
+        float minZ = -10.0;
+        float maxZ = 10.0;
+        float stepX = (maxX - minX) / float(m_xCount - 1);
+        float stepZ = (maxZ - minZ) / float(m_zCount - 1);
+
+        QSurfaceDataArray *dataArray = new QSurfaceDataArray;
+        dataArray->reserve(m_zCount);
+        for (float i = 0; i < m_zCount; i++) {
+            QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+            for (float j = 0; j < m_xCount; j++) {
+                float x = j * stepX + minX;
+                float z = i * stepZ + minZ;
+                float R = qSqrt(x * x + z * z) + 0.01f;
+                float y = (qSin(R) / R + 0.24f) * 1.61f + 1.0f;
+                (*newRow)[j].setPosition(QVector3D(x, y, z));
+            }
+            *dataArray << newRow;
+        }
+
+        m_graph->axisY()->setRange(1.0, 3.0);
+        m_graph->axisX()->setLabelFormat("%.2f");
+        m_graph->axisZ()->setLabelFormat("%.2f");
+
+        resetArrayAndSliders(dataArray, minZ, maxZ, minX, maxX);
+
+        m_activeSample = GraphModifier::SqrtSin;
+    } else {
+        qDebug() << "Remove surface";
+    }
+}
+
+void GraphModifier::togglePlane(bool enable)
+{
+    qDebug() << "GraphModifier::togglePlane " << enable;
+
+    if (enable) {
+        m_planeArray = new QSurfaceDataArray;
+
+#ifdef JITTER_PLANE
+        m_timer.start(0);
+#endif
+        m_graph->axisY()->setRange(0.0, 1.0);
+        m_graph->axisX()->setLabelFormat("%.2f");
+        m_graph->axisZ()->setLabelFormat("%.2f");
+
+        m_planeArray->reserve(m_zCount);
+        float minX = -10.0;
+        float maxX = 20.0;
+        float minZ = -10.0;
+        float maxZ = 10.0;
+        float stepX = (maxX - minX) / float(m_xCount - 1);
+        float stepZ = (maxZ - minZ) / float(m_zCount - 1);
+#ifdef WONKY_PLANE
+        float halfZ = m_zCount / 2;
+        float wonkyFactor = 0.01f;
+        float maxStepX = 0.0f;
+        for (float i = 0; i < m_zCount; i++) {
+            QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+            if (i < halfZ) {
+                stepX += wonkyFactor;
+                maxStepX = stepX;
+            } else {
+                stepX -= wonkyFactor;
+            }
+            for (float j = 0; j < m_xCount; j++) {
+                (*newRow)[j].setPosition(QVector3D(j * stepX + minX, -0.04f,
+                                                   i * stepZ + minZ));
+
+            }
+            *m_planeArray << newRow;
+        }
+
+        resetArrayAndSliders(m_planeArray, minZ, maxZ, minX, m_xCount * maxStepX + minZ);
+#else
+        for (float i = 0; i < m_zCount; i++) {
+            QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+            for (float j = 0; j < m_xCount; j++)
+                (*newRow)[j].setPosition(QVector3D(j * stepX + minX, -0.04f, i * stepZ + minZ));
+
+            *m_planeArray << newRow;
+        }
+
+        resetArrayAndSliders(m_planeArray, minZ, maxZ, minX, maxX);
+#endif
+
+        m_activeSample = GraphModifier::Plane;
+    }
+#ifdef JITTER_PLANE
+    else {
+        m_timer.stop();
+    }
+#endif
+}
+
+void GraphModifier::setHeightMapData(bool enable)
+{
+    if (enable) {
+        // Do the height map the hard way.
+        // Easier alternative would be to use the QHeightMapSurfaceDataProxy.
+        QImage image(":/maps/map");
+
+        QSurfaceDataArray *dataArray = new QSurfaceDataArray;
+        uchar *bits = image.bits();
+
+        int p = image.width() * 4 * (image.height() - 1);
+        dataArray->reserve(image.height());
+        float minX = 34.0;
+        float maxX = 40.0;
+        float minZ = 18.0;
+        float maxZ = 24.0;
+        float xMul = (maxX - minX) / float(image.width() - 1);
+        float zMul = (maxZ - minZ) / float(image.height() - 1);
+        for (int i = 0; i < image.height(); i++, p -= image.width() * 4) {
+            QSurfaceDataRow *newRow = new QSurfaceDataRow(image.width());
+            for (int j = 0; j < image.width(); j++) {
+                (*newRow)[j].setPosition(QVector3D((float(j) * xMul) + minX,
+                                                   (float(bits[p + (j * 4)]) + 1.0f) / 1.0f,
+                                                   (float(i) * zMul) + minZ));
+            }
+            *dataArray << newRow;
+        }
+
+        m_graph->axisY()->setAutoAdjustRange(true);
+        m_graph->axisX()->setLabelFormat("%.1f N");
+        m_graph->axisZ()->setLabelFormat("%.1f E");
+
+        resetArrayAndSliders(dataArray, minZ, maxZ, minX, maxX);
+
+        m_activeSample = GraphModifier::Map;
+    }
+}
+
+void GraphModifier::toggleGridSliderLock(bool enable)
+{
+    m_gridSlidersLocked = enable;
+    if (m_gridSlidersLocked) {
+        m_gridSliderZ->setEnabled(false);
+        m_gridSliderZ->setValue(m_gridSliderX->value());
+    } else {
+        m_gridSliderZ->setEnabled(true);
+    }
+}
+
+void GraphModifier::adjustXCount(int count)
+{
+    m_xCount = count;
+    if (m_gridSlidersLocked)
+        m_gridSliderZ->setValue(count);
+
+    updateSamples();
+
+    qDebug() << "X count =" << count;
+}
+
+void GraphModifier::adjustZCount(int count)
+{
+    m_zCount = count;
+
+    updateSamples();
+
+    qDebug() << "Z count =" << count;
+}
+
+void GraphModifier::adjustXRange(int range)
+{
+    m_rangeX = range;
+    m_graph->axisX()->setRange(m_minX, m_minX + m_rangeX);
+
+    qDebug() << "X Range =" << range;
+}
+
+void GraphModifier::adjustZRange(int range)
+{
+    m_rangeZ = range;
+    m_graph->axisZ()->setRange(m_minZ, m_minZ + m_rangeZ);
+
+    qDebug() << "Z Range =" << range;
+}
+
+void GraphModifier::adjustXMin(int min)
+{
+    m_minX = min;
+    m_graph->axisX()->setRange(m_minX, m_minX + m_rangeX);
+
+    qDebug() << "X Minimum =" << min;
+}
+
+void GraphModifier::adjustZMin(int min)
+{
+    m_minZ = min;
+    m_graph->axisZ()->setRange(m_minZ, m_minZ + m_rangeZ);
+
+    qDebug() << "Z Minimum =" << min;
+}
+
+void GraphModifier::gradientPressed()
+{
+    QLinearGradient gradient;
+    gradient.setColorAt(0.0, Qt::black);
+    gradient.setColorAt(0.33, Qt::blue);
+    gradient.setColorAt(0.67, Qt::red);
+    gradient.setColorAt(1.0, Qt::yellow);
+    m_graph->setGradient(gradient);
+}
+
+void GraphModifier::changeFont(const QFont &font)
+{
+    QFont newFont = font;
+    newFont.setPointSizeF(m_fontSize);
+    m_graph->setFont(newFont);
+}
+
+void GraphModifier::changeStyle()
+{
+    static int style = QDataVis::LabelStyleFromTheme;
+
+    m_graph->setLabelStyle((QDataVis::LabelStyle)style);
+
+    if (++style > QDataVis::LabelStyleTransparent)
+        style = QDataVis::LabelStyleOpaque;
+}
+
+void GraphModifier::changeTheme(int theme)
+{
+    m_graph->setTheme((QDataVis::Theme)theme);
+}
+
+void GraphModifier::timeout()
+{
+    int rows = m_planeArray->size();
+    int columns = m_planeArray->at(0)->size();
+
+    // Induce minor random jitter to the existing plane array
+    for (int i = 0; i < rows; i++) {
+        for (int j = 0; j < columns; j++) {
+            (*m_planeArray->at(i))[j].setX(m_planeArray->at(i)->at(j).x()
+                                           * ((float((rand() % 10) + 5.0f) / 10000.0f) + 0.999f));
+            (*m_planeArray->at(i))[j].setY(m_planeArray->at(i)->at(j).y()
+                                           * ((float((rand() % 10) + 5.0f) / 1000.0f) + 0.99f) + 0.0001f);
+            (*m_planeArray->at(i))[j].setZ(m_planeArray->at(i)->at(j).z()
+                                           * ((float((rand() % 10) + 5.0f) / 10000.0f) + 0.999f));
+        }
+    }
+
+    // Reset same array to make it redraw
+    m_graph->activeDataProxy()->resetArray(m_planeArray);
+}
+
+void GraphModifier::resetArrayAndSliders(QSurfaceDataArray *array, qreal minZ, qreal maxZ, qreal minX, qreal maxX)
+{
+    m_axisMinSliderX->setValue(minX);
+    m_axisMinSliderZ->setValue(minZ);
+    m_axisRangeSliderX->setValue(maxX - minX);
+    m_axisRangeSliderZ->setValue(maxZ - minZ);
+
+    m_graph->activeDataProxy()->resetArray(array);
+}
+
+void GraphModifier::changeShadowQuality(int quality)
+{
+    QDataVis::ShadowQuality sq = QDataVis::ShadowQuality(quality);
+    m_graph->setShadowQuality(sq);
+}
+
+void GraphModifier::changeSelectionMode(int mode)
+{
+    switch (mode) {
+    case 0:
+        qDebug() << "QDataVis::SelectionModeNone";
+        m_graph->setSelectionMode(QDataVis::SelectionModeNone);
+        break;
+    case 1:
+        qDebug() << "QDataVis::SelectionModeItem";
+        m_graph->setSelectionMode(QDataVis::SelectionModeItem);
+        break;
+    case 2:
+        qDebug() << "QDataVis::SelectionModeSliceRow";
+        m_graph->setSelectionMode(QDataVis::SelectionModeSliceRow);
+        break;
+    case 3:
+        qDebug() << "QDataVis::SelectionModeSliceColumn";
+        m_graph->setSelectionMode(QDataVis::SelectionModeSliceColumn);
+        break;
+    default:
+        qDebug() << __FUNCTION__ << " Unsupported selection mode.";
+        break;
+    }
+}
+
+void GraphModifier::updateSamples()
+{
+    switch (m_activeSample) {
+    case SqrtSin:
+        toggleSqrtSin(true);
+        break;
+
+    case Plane:
+        togglePlane(true);
+        break;
+
+    default:
+        break;
+    }
+}
+
diff --git a/tests/surfacetest/graphmodifier.h b/tests/surfacetest/graphmodifier.h
new file mode 100644
index 00000000..83b1873b
--- /dev/null
+++ b/tests/surfacetest/graphmodifier.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the QtDataVisualization module.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+**
+****************************************************************************/
+
+#ifndef GRAPHMODIFIER_H
+#define GRAPHMODIFIER_H
+
+#include <QtDataVisualization/Q3DSurface>
+#include <QtDataVisualization/QSurfaceDataProxy>
+#include <QSlider>
+#include <QTimer>
+
+using namespace QtDataVisualization;
+
+class GraphModifier : public QObject
+{
+    Q_OBJECT
+public:
+    enum Samples {
+        SqrtSin = 1,
+        Plane,
+        Map
+    };
+
+    explicit GraphModifier(Q3DSurface *graph);
+    ~GraphModifier();
+
+    void toggleSmooth(bool enabled);
+    void toggleSurfaceGrid(bool enable);
+    void toggleSqrtSin(bool enable);
+    void togglePlane(bool enable);
+    void setHeightMapData(bool enable);
+    void toggleGridSliderLock(bool enable);
+    void setGridSliderX(QSlider *slider) { m_gridSliderX = slider; }
+    void setGridSliderZ(QSlider *slider) { m_gridSliderZ = slider; }
+    void setAxisRangeSliderX(QSlider *slider) { m_axisRangeSliderX = slider; }
+    void setAxisRangeSliderZ(QSlider *slider) { m_axisRangeSliderZ = slider; }
+    void setAxisMinSliderX(QSlider *slider) { m_axisMinSliderX = slider; }
+    void setAxisMinSliderZ(QSlider *slider) { m_axisMinSliderZ = slider; }
+    void adjustXCount(int count);
+    void adjustZCount(int count);
+    void adjustXRange(int range);
+    void adjustZRange(int range);
+    void adjustXMin(int min);
+    void adjustZMin(int min);
+    void updateSamples();
+    void gradientPressed();
+    void changeFont(const QFont &font);
+    void changeStyle();
+
+public slots:
+    void changeShadowQuality(int quality);
+    void changeTheme(int theme);
+    void changeSelectionMode(int mode);
+    void timeout();
+
+private:
+    void resetArrayAndSliders(QSurfaceDataArray *array, qreal minZ, qreal maxZ, qreal minX,
+                              qreal maxX);
+
+    Q3DSurface *m_graph;
+    QSlider *m_gridSliderX;
+    QSlider *m_gridSliderZ;
+    QSlider *m_axisRangeSliderX;
+    QSlider *m_axisRangeSliderZ;
+    QSlider *m_axisMinSliderX;
+    QSlider *m_axisMinSliderZ;
+    bool m_gridSlidersLocked;
+    int m_xCount;
+    int m_zCount;
+    int m_activeSample;
+    int m_fontSize;
+    qreal m_rangeX;
+    qreal m_rangeZ;
+    qreal m_minX;
+    qreal m_minZ;
+    QTimer m_timer;
+    QSurfaceDataArray *m_planeArray;
+};
+
+#endif
diff --git a/tests/surfacetest/main.cpp b/tests/surfacetest/main.cpp
new file mode 100644
index 00000000..19f30e5d
--- /dev/null
+++ b/tests/surfacetest/main.cpp
@@ -0,0 +1,256 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the QtDataVisualization module.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+**
+****************************************************************************/
+
+#include "graphmodifier.h"
+
+#include <QApplication>
+#include <QWidget>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QRadioButton>
+#include <QSlider>
+#include <QLabel>
+#include <QScreen>
+#include <QPainter>
+#include <QFontComboBox>
+#include <QDebug>
+
+using namespace QtDataVisualization;
+
+const int initialTheme = 4;
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+
+    QWidget *widget = new QWidget;
+    QHBoxLayout *hLayout = new QHBoxLayout(widget);
+    QVBoxLayout *vLayout = new QVBoxLayout();
+    vLayout->setAlignment(Qt::AlignTop);
+
+    Q3DSurface *surfaceGraph = new Q3DSurface();
+    QSize screenSize = surfaceGraph->screen()->size();
+
+    // Set to default, should be same as the initial on themeList
+    surfaceGraph->setTheme(QDataVis::Theme(initialTheme));
+
+    QWidget *container = QWidget::createWindowContainer(surfaceGraph);
+    container->setMinimumSize(QSize(screenSize.width() / 2, screenSize.height() / 2));
+    container->setMaximumSize(screenSize);
+    container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    container->setFocusPolicy(Qt::StrongFocus);
+
+    widget->setWindowTitle(QStringLiteral("Surface tester"));
+
+    hLayout->addWidget(container, 1);
+    hLayout->addLayout(vLayout);
+
+    QCheckBox *smoothCB = new QCheckBox(widget);
+    smoothCB->setText(QStringLiteral("Smooth "));
+    smoothCB->setChecked(surfaceGraph->isSmoothSurfaceEnabled());
+
+    QCheckBox *surfaceGridCB = new QCheckBox(widget);
+    surfaceGridCB->setText(QStringLiteral("Surface Grid"));
+    surfaceGridCB->setChecked(true);
+
+    //QCheckBox *sqrtSinCB = new QCheckBox(widget);
+    QRadioButton *sqrtSinCB = new QRadioButton(widget);
+    sqrtSinCB->setText(QStringLiteral("Sqrt & Sin"));
+    sqrtSinCB->setChecked(false);
+
+    QRadioButton *planeCB = new QRadioButton(widget);
+    planeCB->setText(QStringLiteral("Plane"));
+    planeCB->setChecked(false);
+
+    QRadioButton *heightMapCB = new QRadioButton(widget);
+    heightMapCB->setText(QStringLiteral("Height map"));
+    heightMapCB->setChecked(false);
+
+    QCheckBox *gridSlidersLockCB = new QCheckBox(widget);
+    gridSlidersLockCB->setText(QStringLiteral("Lock"));
+    gridSlidersLockCB->setChecked(false);
+
+    QSlider *gridSliderX = new QSlider(Qt::Horizontal, widget);
+    gridSliderX->setTickInterval(1);
+    gridSliderX->setMinimum(2);
+    gridSliderX->setValue(30);
+    gridSliderX->setMaximum(200);
+    gridSliderX->setEnabled(true);
+    QSlider *gridSliderZ = new QSlider(Qt::Horizontal, widget);
+    gridSliderZ->setTickInterval(1);
+    gridSliderZ->setMinimum(2);
+    gridSliderZ->setValue(30);
+    gridSliderZ->setMaximum(200);
+    gridSliderZ->setEnabled(true);
+
+    QSlider *axisRangeSliderX = new QSlider(Qt::Horizontal, widget);
+    axisRangeSliderX->setTickInterval(1);
+    axisRangeSliderX->setMinimum(2);
+    axisRangeSliderX->setValue(16);
+    axisRangeSliderX->setMaximum(100);
+    axisRangeSliderX->setEnabled(true);
+    QSlider *axisRangeSliderZ = new QSlider(Qt::Horizontal, widget);
+    axisRangeSliderZ->setTickInterval(1);
+    axisRangeSliderZ->setMinimum(2);
+    axisRangeSliderZ->setValue(16);
+    axisRangeSliderZ->setMaximum(100);
+    axisRangeSliderZ->setEnabled(true);
+
+    QSlider *axisMinSliderX = new QSlider(Qt::Horizontal, widget);
+    axisMinSliderX->setTickInterval(1);
+    axisMinSliderX->setMinimum(-50);
+    axisMinSliderX->setValue(-8);
+    axisMinSliderX->setMaximum(50);
+    axisMinSliderX->setEnabled(true);
+    QSlider *axisMinSliderZ = new QSlider(Qt::Horizontal, widget);
+    axisMinSliderZ->setTickInterval(1);
+    axisMinSliderZ->setMinimum(-50);
+    axisMinSliderZ->setValue(-8);
+    axisMinSliderZ->setMaximum(50);
+    axisMinSliderZ->setEnabled(true);
+
+    QLinearGradient gr(0, 0, 100, 1);
+    gr.setColorAt(0.0, Qt::black);
+    gr.setColorAt(0.33, Qt::blue);
+    gr.setColorAt(0.67, Qt::red);
+    gr.setColorAt(1.0, Qt::yellow);
+    QPixmap pm(100, 24);
+    QPainter pmp(&pm);
+    pmp.setBrush(QBrush(gr));
+    pmp.setPen(Qt::NoPen);
+    pmp.drawRect(0, 0, 100, 24);
+    QPushButton *colorPB = new QPushButton();
+    colorPB->setIcon(QIcon(pm));
+    colorPB->setIconSize(QSize(100, 24));
+
+    QFontComboBox *fontList = new QFontComboBox(widget);
+    fontList->setCurrentFont(QFont("Arial"));
+
+    QPushButton *labelButton = new QPushButton(widget);
+    labelButton->setText(QStringLiteral("Change label style"));
+
+    QComboBox *themeList = new QComboBox(widget);
+    themeList->addItem(QStringLiteral("Qt"));
+    themeList->addItem(QStringLiteral("Primary Colors"));
+    themeList->addItem(QStringLiteral("Digia"));
+    themeList->addItem(QStringLiteral("Stone Moss"));
+    themeList->addItem(QStringLiteral("Army Blue"));
+    themeList->addItem(QStringLiteral("Retro"));
+    themeList->addItem(QStringLiteral("Ebony"));
+    themeList->addItem(QStringLiteral("Isabelle"));
+    themeList->setCurrentIndex(initialTheme);
+
+//    QComboBox *shadowQuality = new QComboBox(widget);
+//    shadowQuality->addItem(QStringLiteral("None"));
+//    shadowQuality->addItem(QStringLiteral("Low"));
+//    shadowQuality->addItem(QStringLiteral("Medium"));
+//    shadowQuality->addItem(QStringLiteral("High"));
+//    shadowQuality->addItem(QStringLiteral("Low Soft"));
+//    shadowQuality->addItem(QStringLiteral("Medium Soft"));
+//    shadowQuality->addItem(QStringLiteral("High Soft"));
+//    shadowQuality->setCurrentIndex(3);
+    QComboBox *selectionMode = new QComboBox(widget);
+    selectionMode->addItem(QStringLiteral("SelectionModeNone"));
+    selectionMode->addItem(QStringLiteral("SelectionModeItem"));
+    selectionMode->addItem(QStringLiteral("SelectionModeSliceRow"));
+    selectionMode->addItem(QStringLiteral("SelectionModeSliceColumn"));
+    selectionMode->setCurrentIndex(1);
+
+    // Add controls to the layout
+    vLayout->addWidget(smoothCB);
+    vLayout->addWidget(surfaceGridCB);
+    vLayout->addWidget(new QLabel(QStringLiteral("Select surface sample")));
+    vLayout->addWidget(sqrtSinCB);
+    vLayout->addWidget(planeCB);
+    vLayout->addWidget(heightMapCB);
+    vLayout->addWidget(new QLabel(QStringLiteral("Adjust sample count")));
+    vLayout->addWidget(gridSlidersLockCB);
+    vLayout->addWidget(gridSliderX);
+    vLayout->addWidget(gridSliderZ);
+    vLayout->addWidget(new QLabel(QStringLiteral("Adjust axis range")));
+    vLayout->addWidget(axisRangeSliderX);
+    vLayout->addWidget(axisRangeSliderZ);
+    vLayout->addWidget(new QLabel(QStringLiteral("Adjust axis minimum")));
+    vLayout->addWidget(axisMinSliderX);
+    vLayout->addWidget(axisMinSliderZ);
+    vLayout->addWidget(colorPB);
+    vLayout->addWidget(new QLabel(QStringLiteral("Change font")));
+    vLayout->addWidget(fontList);
+    vLayout->addWidget(labelButton);
+    vLayout->addWidget(new QLabel(QStringLiteral("Change theme")));
+    vLayout->addWidget(themeList);
+//    vLayout->addWidget(new QLabel(QStringLiteral("Adjust shadow quality")));
+//    vLayout->addWidget(shadowQuality);
+    vLayout->addWidget(new QLabel(QStringLiteral("Selection Mode")));
+    vLayout->addWidget(selectionMode);
+
+    widget->show();
+
+    GraphModifier *modifier = new GraphModifier(surfaceGraph);
+
+    // Connect controls to slots on modifier
+    QObject::connect(smoothCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSmooth);
+    QObject::connect(surfaceGridCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceGrid);
+    QObject::connect(sqrtSinCB, &QRadioButton::toggled,
+                     modifier, &GraphModifier::toggleSqrtSin);
+    QObject::connect(planeCB, &QCheckBox::toggled,
+                     modifier, &GraphModifier::togglePlane);
+    QObject::connect(heightMapCB, &QCheckBox::toggled,
+                     modifier, &GraphModifier::setHeightMapData);
+    QObject::connect(gridSlidersLockCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleGridSliderLock);
+    QObject::connect(gridSliderX, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustXCount);
+    QObject::connect(gridSliderZ, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustZCount);
+    QObject::connect(axisRangeSliderX, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustXRange);
+    QObject::connect(axisRangeSliderZ, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustZRange);
+    QObject::connect(axisMinSliderX, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustXMin);
+    QObject::connect(axisMinSliderZ, &QSlider::valueChanged,
+                     modifier, &GraphModifier::adjustZMin);
+    QObject::connect(colorPB, &QPushButton::pressed,
+                     modifier, &GraphModifier::gradientPressed);
+    QObject::connect(fontList, &QFontComboBox::currentFontChanged,
+                     modifier, &GraphModifier::changeFont);
+    QObject::connect(labelButton, &QPushButton::clicked,
+                     modifier, &GraphModifier::changeStyle);
+    QObject::connect(themeList, SIGNAL(currentIndexChanged(int)),
+                     modifier, SLOT(changeTheme(int)));
+//    QObject::connect(shadowQuality, SIGNAL(currentIndexChanged(int)),
+//                     modifier, SLOT(changeShadowQuality(int)));
+    QObject::connect(selectionMode, SIGNAL(currentIndexChanged(int)),
+                     modifier, SLOT(changeSelectionMode(int)));
+
+    modifier->setGridSliderZ(gridSliderZ);
+    modifier->setGridSliderX(gridSliderX);
+    modifier->setAxisRangeSliderX(axisRangeSliderX);
+    modifier->setAxisRangeSliderZ(axisRangeSliderZ);
+    modifier->setAxisMinSliderX(axisMinSliderX);
+    modifier->setAxisMinSliderZ(axisMinSliderZ);
+    modifier->toggleGridSliderLock(gridSlidersLockCB->checkState());
+    sqrtSinCB->setChecked(true);
+
+    return app.exec();
+}
diff --git a/tests/surfacetest/surfacetest.pro b/tests/surfacetest/surfacetest.pro
new file mode 100644
index 00000000..9ab890a7
--- /dev/null
+++ b/tests/surfacetest/surfacetest.pro
@@ -0,0 +1,16 @@
+!include( ../tests.pri ) {
+    error( "Couldn't find the tests.pri file!" )
+}
+
+SOURCES += main.cpp \
+    graphmodifier.cpp
+
+QT += widgets
+
+INSTALLS += target
+
+HEADERS += \
+    graphmodifier.h
+
+RESOURCES += \
+    surfacetest.qrc
diff --git a/tests/surfacetest/surfacetest.qrc b/tests/surfacetest/surfacetest.qrc
new file mode 100644
index 00000000..c18da2c4
--- /dev/null
+++ b/tests/surfacetest/surfacetest.qrc
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/maps">
+        <file alias="map">Heightmap.png</file>
+    </qresource>
+</RCC>
diff --git a/tests/tests.pro b/tests/tests.pro
index 61082096..a9462378 100644
--- a/tests/tests.pro
+++ b/tests/tests.pro
@@ -9,6 +9,7 @@ TEMPLATE = subdirs
 
 SUBDIRS += barstest \
            scattertest \
-           kinectsurface
+           kinectsurface \
+           surfacetest
 
 qtHaveModule(multimedia):!android: SUBDIRS += spectrum