Multiseries support for surface

Task-number: QTRD-2767

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

3 files changed, 560 insertions, 12 deletions

diff --git a/tests/surfacetest/graphmodifier.cpp b/tests/surfacetest/graphmodifier.cpp
index 528a803b..c6247bb5 100644
--- a/tests/surfacetest/graphmodifier.cpp
+++ b/tests/surfacetest/graphmodifier.cpp
@@ -34,14 +34,18 @@ using namespace QtDataVisualization;
 
 GraphModifier::GraphModifier(Q3DSurface *graph)
     : m_graph(graph),
+      m_series1(new QSurface3DSeries),
+      m_series2(new QSurface3DSeries),
+      m_series3(new QSurface3DSeries),
+      m_series4(new QSurface3DSeries),
       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_xCount(24),
+      m_zCount(24),
       m_activeSample(0),
       m_fontSize(40),
       m_rangeX(16.0),
@@ -53,15 +57,32 @@ GraphModifier::GraphModifier(Q3DSurface *graph)
       m_insertTestIndexPos(1),
       m_planeArray(0),
       m_theSeries(new QSurface3DSeries),
-      m_drawMode(QSurface3DSeries::DrawSurfaceAndWireframe)
+      m_drawMode(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode2(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode3(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode4(QSurface3DSeries::DrawSurfaceAndWireframe)
 {
     m_graph->setAxisX(new QValue3DAxis);
     m_graph->setAxisY(new QValue3DAxis);
     m_graph->setAxisZ(new QValue3DAxis);
+#ifdef MULTI_SERIES
+    m_limitX = float(m_xCount) / 2.0f;
+    m_limitZ = float(m_zCount) / 2.0f;
+    m_graph->axisX()->setRange(-m_limitX, m_limitX);
+    m_graph->axisY()->setRange(-1.0f, 4.5f);
+    m_graph->axisZ()->setRange(-m_limitZ, m_limitZ);
+#else
     m_graph->axisX()->setRange(m_minX, m_minX + m_rangeX);
     m_graph->axisZ()->setRange(m_minZ, m_minZ + m_rangeZ);
     m_graph->addSeries(m_theSeries);
+#endif
+
+    for (int i = 0; i < 4; i++) {
+        m_multiseries[i] = new QSurface3DSeries;
+        m_multiseries[i]->setItemLabelFormat(QStringLiteral("@seriesName: (@xLabel, @zLabel): @yLabel"));
+    }
 
+    fillSeries();
     changeStyle();
 
     m_theSeries->setItemLabelFormat(QStringLiteral("@seriesName: (@xLabel, @zLabel): @yLabel"));
@@ -82,10 +103,100 @@ GraphModifier::~GraphModifier()
     delete m_graph;
 }
 
+void GraphModifier::fillSeries()
+{
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataArray *dataArray1 = new QSurfaceDataArray;
+    dataArray1->reserve(m_zCount);
+    QSurfaceDataArray *dataArray2 = new QSurfaceDataArray;
+    dataArray2->reserve(m_zCount);
+    QSurfaceDataArray *dataArray3 = new QSurfaceDataArray;
+    dataArray3->reserve(m_zCount);
+    QSurfaceDataArray *dataArray4 = new QSurfaceDataArray;
+    dataArray4->reserve(m_zCount);
+
+    for (int i = 0; i < m_zCount; i++) {
+        QSurfaceDataRow *newRow1 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow2 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow3 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow4 = new QSurfaceDataRow(m_xCount);
+
+        for (int j = 0; j < m_xCount; j++) {
+            float x = float(j) - m_limitX + 0.5f;
+            float z = float(i) - m_limitZ + 0.5f;
+            float angle = (z * x) / float(full) * 1.57f;
+            (*newRow1)[j].setPosition(QVector3D(x, qSin(angle), z));
+            angle *= 1.3f;
+            (*newRow2)[j].setPosition(QVector3D(x, qSin(angle) + 1.1f, z));
+            angle *= 1.3f;
+            (*newRow3)[j].setPosition(QVector3D(x, qSin(angle) + 2.2f, z));
+            angle *= 1.3f;
+            (*newRow4)[j].setPosition(QVector3D(x, qSin(angle) + 3.3f, z));
+        }
+        *dataArray1 << newRow1;
+        *dataArray2 << newRow2;
+        *dataArray3 << newRow3;
+        *dataArray4 << newRow4;
+    }
+
+    m_multiseries[0]->dataProxy()->resetArray(dataArray1);
+    m_multiseries[1]->dataProxy()->resetArray(dataArray2);
+    m_multiseries[2]->dataProxy()->resetArray(dataArray3);
+    m_multiseries[3]->dataProxy()->resetArray(dataArray4);
+}
+
+void GraphModifier::toggleSeries1(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[0]);
+    } else {
+        m_graph->removeSeries(m_multiseries[0]);
+    }
+}
+
+void GraphModifier::toggleSeries2(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[1]);
+    } else {
+        m_graph->removeSeries(m_multiseries[1]);
+    }
+}
+
+void GraphModifier::toggleSeries3(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[2]);
+    } else {
+        m_graph->removeSeries(m_multiseries[2]);
+    }
+}
+
+void GraphModifier::toggleSeries4(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[3]);
+    } else {
+        m_graph->removeSeries(m_multiseries[3]);
+    }
+}
+
 void GraphModifier::toggleSmooth(bool enabled)
 {
     qDebug() << "GraphModifier::toggleSmooth " << enabled;
     m_theSeries->setFlatShadingEnabled(enabled);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setFlatShadingEnabled(enabled);
+#endif
 }
 
 void GraphModifier::toggleSurfaceGrid(bool enable)
@@ -97,6 +208,9 @@ void GraphModifier::toggleSurfaceGrid(bool enable)
         m_drawMode &= ~QSurface3DSeries::DrawWireframe;
 
     m_theSeries->setDrawMode(m_drawMode);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setDrawMode(m_drawMode);
+#endif
 }
 
 void GraphModifier::toggleSurface(bool enable)
@@ -108,11 +222,119 @@ void GraphModifier::toggleSurface(bool enable)
         m_drawMode &= ~QSurface3DSeries::DrawSurface;
 
     m_theSeries->setDrawMode(m_drawMode);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setDrawMode(m_drawMode);
+#endif
 }
 
 void GraphModifier::toggleSeriesVisible(bool enable)
 {
     m_theSeries->setVisible(enable);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setVisible(enable);
+#endif
+}
+
+void GraphModifier::toggleSmoothS2(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[1]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS2(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode2 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode2 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[1]->setDrawMode(m_drawMode2);
+}
+
+void GraphModifier::toggleSurfaceS2(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode2 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode2 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[1]->setDrawMode(m_drawMode2);
+}
+
+void GraphModifier::toggleSeries2Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[1]->setVisible(enable);
+}
+
+void GraphModifier::toggleSmoothS3(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[2]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS3(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode3 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode3 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[2]->setDrawMode(m_drawMode3);
+}
+
+void GraphModifier::toggleSurfaceS3(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode3 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode3 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[2]->setDrawMode(m_drawMode3);
+}
+
+void GraphModifier::toggleSeries3Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[2]->setVisible(enable);
+}
+
+void GraphModifier::toggleSmoothS4(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[3]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS4(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode4 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode4 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[3]->setDrawMode(m_drawMode4);
+}
+
+void GraphModifier::toggleSurfaceS4(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode4 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode4 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[3]->setDrawMode(m_drawMode4);
+}
+
+void GraphModifier::toggleSeries4Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[3]->setVisible(enable);
 }
 
 void GraphModifier::toggleSqrtSin(bool enable)
@@ -347,9 +569,14 @@ void GraphModifier::gradientPressed()
     gradient.setColorAt(0.33, Qt::blue);
     gradient.setColorAt(0.67, Qt::red);
     gradient.setColorAt(1.0, Qt::yellow);
-    m_graph->seriesList().at(0)->setBaseGradient(gradient);
-    m_graph->seriesList().at(0)->setSingleHighlightColor(Qt::red);
-    m_graph->seriesList().at(0)->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
+//    m_graph->seriesList().at(0)->setBaseGradient(gradient);
+//    m_graph->seriesList().at(0)->setSingleHighlightColor(Qt::red);
+//    m_graph->seriesList().at(0)->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
+
+    QList<QLinearGradient> gradients;
+    gradients << gradient;
+    m_graph->activeTheme()->setBaseGradients(gradients);
+    m_graph->activeTheme()->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
 }
 
 void GraphModifier::changeFont(const QFont &font)
@@ -572,7 +799,23 @@ void GraphModifier::addRow()
 
         m_theSeries->dataProxy()->addRow(newRow);
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+        qDebug() << "Adding a row into series 3";
+        int full = m_limitX * m_limitZ;
+
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_addRowCounter) - m_limitZ + 0.5f) * (float(j) - m_limitX + 0.5f)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle * 1.3f * 1.3f) + 2.2f,
+                                               float(m_addRowCounter) - m_limitZ + 0.5f));
+        }
+        m_addRowCounter++;
+
+        m_multiseries[2]->dataProxy()->addRow(newRow);
+#else
+            qDebug() << "Add row function active only for SqrtSin";
+#endif
     }
 }
 
@@ -605,7 +848,27 @@ void GraphModifier::addRows()
 
         m_theSeries->dataProxy()->addRows(dataArray);
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Adding 3 rows into series 3";
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataArray dataArray;
+    for (int i = 0; i < 3; i++) {
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_addRowCounter) - m_limitZ + 0.5f) * (float(j) - m_limitX + 0.5f)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle * 1.3f * 1.3f) + 2.2f,
+                                               float(m_addRowCounter) - m_limitZ + 0.5f));
+        }
+        dataArray.append(newRow);
+        m_addRowCounter++;
+    }
+
+    m_multiseries[2]->dataProxy()->addRows(dataArray);
+#else
+        qDebug() << "Add rows function active only for SqrtSin";
+#endif
     }
 }
 
@@ -633,7 +896,25 @@ void GraphModifier::insertRow()
         m_theSeries->dataProxy()->insertRow(m_insertTestIndexPos, newRow);
         m_insertTestIndexPos += 2;
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Inserting a row into series 3";
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+    for (int j = 0; j < m_xCount; j++) {
+        float angle = float((float(m_insertTestZPos) - m_limitZ) * (float(j) - m_limitX)) / float(full) * 1.57f;
+        (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                           qSin(angle) + 2.4f,
+                                           float(m_insertTestZPos) - m_limitZ + 1.0f));
+    }
+
+    m_insertTestZPos++;
+
+    m_multiseries[2]->dataProxy()->insertRow(m_insertTestIndexPos, newRow);
+    m_insertTestIndexPos += 2;
+#else
+        qDebug() << "Insert row function active only for SqrtSin";
+#endif
     }
 }
 
@@ -665,15 +946,47 @@ void GraphModifier::insertRows()
         m_theSeries->dataProxy()->insertRows(m_insertTestIndexPos, dataArray);
         m_insertTestIndexPos += 4;
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Inserting 3 rows into series 3";
+    int full = m_limitX * m_limitZ;
+    QSurfaceDataArray dataArray;
+    float zAdd = 0.25f;
+    for (int i = 0; i < 3; i++) {
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_insertTestZPos) - m_limitZ) * (float(j) - m_limitX)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle) + 2.4f,
+                                               float(m_insertTestZPos) - m_limitZ + 0.5f + zAdd));
+        }
+        zAdd += 0.25f;
+        dataArray.append(newRow);
+    }
+
+    m_insertTestZPos++;
+
+    m_multiseries[2]->dataProxy()->insertRows(m_insertTestIndexPos, dataArray);
+    m_insertTestIndexPos += 4;
+#else
+        qDebug() << "Insert rows function active only for SqrtSin";
+#endif
     }
 }
 
 void GraphModifier::removeRow()
 {
     qDebug() << "Remove an arbitrary row";
+    if (m_zCount < 1)
+        return;
+
     int row = rand() % m_zCount;
+
+#ifdef MULTI_SERIES
+    int series = rand() % 4;
+    m_multiseries[series]->dataProxy()->removeRows(row, 1);
+#else
     m_theSeries->dataProxy()->removeRows(row, 1);
+#endif
     m_zCount--;
 }
 
diff --git a/tests/surfacetest/graphmodifier.h b/tests/surfacetest/graphmodifier.h
index 8ccff62f..308db1f0 100644
--- a/tests/surfacetest/graphmodifier.h
+++ b/tests/surfacetest/graphmodifier.h
@@ -25,6 +25,9 @@
 #include <QSlider>
 #include <QTimer>
 #include <QLabel>
+#include <QCheckBox>
+
+#define MULTI_SERIES
 
 using namespace QtDataVisualization;
 
@@ -41,10 +44,27 @@ public:
     explicit GraphModifier(Q3DSurface *graph);
     ~GraphModifier();
 
+    void toggleSeries1(bool enabled);
+    void toggleSeries2(bool enabled);
+    void toggleSeries3(bool enabled);
+    void toggleSeries4(bool enabled);
     void toggleSmooth(bool enabled);
     void toggleSurfaceGrid(bool enable);
     void toggleSurface(bool enable);
     void toggleSeriesVisible(bool enable);
+    void toggleSmoothS2(bool enabled);
+    void toggleSurfaceGridS2(bool enable);
+    void toggleSurfaceS2(bool enable);
+    void toggleSeries2Visible(bool enable);
+    void toggleSmoothS3(bool enabled);
+    void toggleSurfaceGridS3(bool enable);
+    void toggleSurfaceS3(bool enable);
+    void toggleSeries3Visible(bool enable);
+    void toggleSmoothS4(bool enabled);
+    void toggleSurfaceGridS4(bool enable);
+    void toggleSurfaceS4(bool enable);
+    void toggleSeries4Visible(bool enable);
+
     void toggleSqrtSin(bool enable);
     void togglePlane(bool enable);
     void setHeightMapData(bool enable);
@@ -55,6 +75,10 @@ public:
     void setAxisRangeSliderZ(QSlider *slider) { m_axisRangeSliderZ = slider; }
     void setAxisMinSliderX(QSlider *slider) { m_axisMinSliderX = slider; }
     void setAxisMinSliderZ(QSlider *slider) { m_axisMinSliderZ = slider; }
+    void setSeries1CB(QCheckBox *cb) { m_series1CB = cb; }
+    void setSeries2CB(QCheckBox *cb) { m_series2CB = cb; }
+    void setSeries3CB(QCheckBox *cb) { m_series3CB = cb; }
+    void setSeries4CB(QCheckBox *cb) { m_series4CB = cb; }
     void adjustXCount(int count);
     void adjustZCount(int count);
     void adjustXRange(int range);
@@ -92,16 +116,26 @@ public slots:
     void handleAxisZChanged(QValue3DAxis *axis);
 
 private:
+    void fillSeries();
     void resetArrayAndSliders(QSurfaceDataArray *array, float minZ, float maxZ, float minX,
                               float maxX);
 
     Q3DSurface *m_graph;
+    QSurface3DSeries *m_multiseries[4];
+    QSurface3DSeries *m_series1;
+    QSurface3DSeries *m_series2;
+    QSurface3DSeries *m_series3;
+    QSurface3DSeries *m_series4;
     QSlider *m_gridSliderX;
     QSlider *m_gridSliderZ;
     QSlider *m_axisRangeSliderX;
     QSlider *m_axisRangeSliderZ;
     QSlider *m_axisMinSliderX;
     QSlider *m_axisMinSliderZ;
+    QCheckBox *m_series1CB;
+    QCheckBox *m_series2CB;
+    QCheckBox *m_series3CB;
+    QCheckBox *m_series4CB;
     bool m_gridSlidersLocked;
     int m_xCount;
     int m_zCount;
@@ -119,6 +153,11 @@ private:
     QLabel *m_selectionInfoLabel;
     QSurface3DSeries *m_theSeries;
     QSurface3DSeries::DrawFlags m_drawMode;
+    QSurface3DSeries::DrawFlags m_drawMode2;
+    QSurface3DSeries::DrawFlags m_drawMode3;
+    QSurface3DSeries::DrawFlags m_drawMode4;
+    float m_limitX;
+    float m_limitZ;
 };
 
 #endif
diff --git a/tests/surfacetest/main.cpp b/tests/surfacetest/main.cpp
index b31586b0..408486f5 100644
--- a/tests/surfacetest/main.cpp
+++ b/tests/surfacetest/main.cpp
@@ -31,6 +31,7 @@
 #include <QScreen>
 #include <QPainter>
 #include <QFontComboBox>
+#include <QFrame>
 #include <QDebug>
 
 using namespace QtDataVisualization;
@@ -82,6 +83,72 @@ int main(int argc, char *argv[])
     seriesVisibleCB->setText(QStringLiteral("Series Visible"));
     seriesVisibleCB->setChecked(true);
 
+#ifdef MULTI_SERIES
+    smoothCB->setText(QStringLiteral("S1 Flat Surface"));
+    surfaceGridCB->setText(QStringLiteral("S1 Surface Grid"));
+    surfaceCB->setText(QStringLiteral("S1 Surface Visible"));
+    seriesVisibleCB->setText(QStringLiteral("Series 1 Visible"));
+
+    QCheckBox *smoothS2CB = new QCheckBox(widget);
+    smoothS2CB->setText(QStringLiteral("S2 Flat Surface"));
+    smoothS2CB->setChecked(true);
+
+    QCheckBox *surfaceGridS2CB = new QCheckBox(widget);
+    surfaceGridS2CB->setText(QStringLiteral("S2 Surface Grid"));
+    surfaceGridS2CB->setChecked(true);
+
+    QCheckBox *surfaceS2CB = new QCheckBox(widget);
+    surfaceS2CB->setText(QStringLiteral("S2 Surface Visible"));
+    surfaceS2CB->setChecked(true);
+
+    QCheckBox *series2VisibleCB = new QCheckBox(widget);
+    series2VisibleCB->setText(QStringLiteral("Series 2 Visible"));
+    series2VisibleCB->setChecked(true);
+
+    QCheckBox *smoothS3CB = new QCheckBox(widget);
+    smoothS3CB->setText(QStringLiteral("S3 Flat Surface"));
+    smoothS3CB->setChecked(true);
+
+    QCheckBox *surfaceGridS3CB = new QCheckBox(widget);
+    surfaceGridS3CB->setText(QStringLiteral("S3 Surface Grid"));
+    surfaceGridS3CB->setChecked(true);
+
+    QCheckBox *surfaceS3CB = new QCheckBox(widget);
+    surfaceS3CB->setText(QStringLiteral("S3 Surface Visible"));
+    surfaceS3CB->setChecked(true);
+
+    QCheckBox *series3VisibleCB = new QCheckBox(widget);
+    series3VisibleCB->setText(QStringLiteral("Series 3 Visible"));
+    series3VisibleCB->setChecked(true);
+
+    QCheckBox *smoothS4CB = new QCheckBox(widget);
+    smoothS4CB->setText(QStringLiteral("S4 Flat Surface"));
+    smoothS4CB->setChecked(true);
+
+    QCheckBox *surfaceGridS4CB = new QCheckBox(widget);
+    surfaceGridS4CB->setText(QStringLiteral("S4 Surface Grid"));
+    surfaceGridS4CB->setChecked(true);
+
+    QCheckBox *surfaceS4CB = new QCheckBox(widget);
+    surfaceS4CB->setText(QStringLiteral("S4 Surface Visible"));
+    surfaceS4CB->setChecked(true);
+
+    QCheckBox *series4VisibleCB = new QCheckBox(widget);
+    series4VisibleCB->setText(QStringLiteral("Series 4 Visible"));
+    series4VisibleCB->setChecked(true);
+
+    QCheckBox *series1CB = new QCheckBox(widget);
+    series1CB->setText(QStringLiteral("Series 1"));
+
+    QCheckBox *series2CB = new QCheckBox(widget);
+    series2CB->setText(QStringLiteral("Series 2"));
+
+    QCheckBox *series3CB = new QCheckBox(widget);
+    series3CB->setText(QStringLiteral("Series 3"));
+
+    QCheckBox *series4CB = new QCheckBox(widget);
+    series4CB->setText(QStringLiteral("Series 4"));
+#else
     //QCheckBox *sqrtSinCB = new QCheckBox(widget);
     QRadioButton *sqrtSinCB = new QRadioButton(widget);
     sqrtSinCB->setText(QStringLiteral("Sqrt & Sin"));
@@ -111,6 +178,7 @@ int main(int argc, char *argv[])
     gridSliderZ->setValue(30);
     gridSliderZ->setMaximum(200);
     gridSliderZ->setEnabled(true);
+#endif
 
     QSlider *axisRangeSliderX = new QSlider(Qt::Horizontal, widget);
     axisRangeSliderX->setTickInterval(1);
@@ -209,6 +277,7 @@ int main(int argc, char *argv[])
                                int(QAbstract3DGraph::SelectionSlice | QAbstract3DGraph::SelectionItemAndColumn));
     selectionMode->setCurrentIndex(1);
 
+#ifndef MULTI_SERIES
     QPushButton *selectButton = new QPushButton(widget);
     selectButton->setText(QStringLiteral("Select random point"));
 
@@ -216,6 +285,7 @@ int main(int argc, char *argv[])
     flipViewsButton->setText(QStringLiteral("Flip Views"));
 
     QLabel *selectionInfoLabel = new QLabel(widget);
+#endif
 
     QPushButton *changeRowButton = new QPushButton(widget);
     changeRowButton->setText(QStringLiteral("Change a row"));
@@ -247,11 +317,47 @@ int main(int argc, char *argv[])
     QPushButton *removeRowButton = new QPushButton(widget);
     removeRowButton->setText(QStringLiteral("Remove a row"));
 
+    QFrame* line = new QFrame();
+    line->setFrameShape(QFrame::HLine);
+    line->setFrameShadow(QFrame::Sunken);
+
+    QFrame* line2 = new QFrame();
+    line2->setFrameShape(QFrame::HLine);
+    line2->setFrameShadow(QFrame::Sunken);
+
+    QFrame* line3 = new QFrame();
+    line3->setFrameShape(QFrame::HLine);
+    line3->setFrameShadow(QFrame::Sunken);
+
     // Add controls to the layout
+#ifdef MULTI_SERIES
+    vLayout->addWidget(series1CB);
+#endif
     vLayout->addWidget(smoothCB);
     vLayout->addWidget(surfaceGridCB);
     vLayout->addWidget(surfaceCB);
     vLayout->addWidget(seriesVisibleCB);
+#ifdef MULTI_SERIES
+    vLayout->addWidget(line);
+    vLayout->addWidget(series2CB);
+    vLayout->addWidget(smoothS2CB);
+    vLayout->addWidget(surfaceGridS2CB);
+    vLayout->addWidget(surfaceS2CB);
+    vLayout->addWidget(series2VisibleCB);
+    vLayout->addWidget(line2);
+    vLayout->addWidget(series3CB);
+    vLayout->addWidget(smoothS3CB);
+    vLayout->addWidget(surfaceGridS3CB);
+    vLayout->addWidget(surfaceS3CB);
+    vLayout->addWidget(series3VisibleCB);
+    vLayout->addWidget(line3);
+    vLayout->addWidget(series4CB);
+    vLayout->addWidget(smoothS4CB);
+    vLayout->addWidget(surfaceGridS4CB);
+    vLayout->addWidget(surfaceS4CB);
+    vLayout->addWidget(series4VisibleCB);
+#endif
+#ifndef MULTI_SERIES
     vLayout->addWidget(new QLabel(QStringLiteral("Select surface sample")));
     vLayout->addWidget(sqrtSinCB);
     vLayout->addWidget(planeCB);
@@ -260,6 +366,7 @@ int main(int argc, char *argv[])
     vLayout->addWidget(gridSlidersLockCB);
     vLayout->addWidget(gridSliderX);
     vLayout->addWidget(gridSliderZ);
+#endif
     vLayout->addWidget(new QLabel(QStringLiteral("Adjust axis range")));
     vLayout->addWidget(axisRangeSliderX);
     vLayout->addWidget(axisRangeSliderZ);
@@ -277,9 +384,11 @@ int main(int argc, char *argv[])
     vLayout->addWidget(shadowQuality);
     vLayout->addWidget(new QLabel(QStringLiteral("Selection Mode")));
     vLayout->addWidget(selectionMode);
+#ifndef MULTI_SERIES
     vLayout->addWidget(selectButton);
     vLayout->addWidget(selectionInfoLabel);
     vLayout->addWidget(flipViewsButton);
+#endif
 
     vLayout2->addWidget(changeRowButton);
     vLayout2->addWidget(changeRowsButton);
@@ -305,6 +414,78 @@ int main(int argc, char *argv[])
                      modifier, &GraphModifier::toggleSurface);
     QObject::connect(seriesVisibleCB, &QCheckBox::stateChanged,
                      modifier, &GraphModifier::toggleSeriesVisible);
+#ifdef MULTI_SERIES
+    QObject::connect(smoothS2CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSmoothS2);
+    QObject::connect(surfaceGridS2CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceGridS2);
+    QObject::connect(surfaceS2CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceS2);
+    QObject::connect(series2VisibleCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries2Visible);
+
+    QObject::connect(smoothS3CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSmoothS3);
+    QObject::connect(surfaceGridS3CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceGridS3);
+    QObject::connect(surfaceS3CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceS3);
+    QObject::connect(series3VisibleCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries3Visible);
+
+    QObject::connect(smoothS4CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSmoothS4);
+    QObject::connect(surfaceGridS4CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceGridS4);
+    QObject::connect(surfaceS4CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSurfaceS4);
+    QObject::connect(series4VisibleCB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries4Visible);
+
+    QObject::connect(series1CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries1);
+    QObject::connect(series1CB, &QCheckBox::stateChanged,
+                     smoothCB, &QPushButton::setEnabled);
+    QObject::connect(series1CB, &QCheckBox::stateChanged,
+                     surfaceGridCB, &QPushButton::setEnabled);
+    QObject::connect(series1CB, &QCheckBox::stateChanged,
+                     surfaceCB, &QPushButton::setEnabled);
+    QObject::connect(series1CB, &QCheckBox::stateChanged,
+                     seriesVisibleCB, &QPushButton::setEnabled);
+
+    QObject::connect(series2CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries2);
+    QObject::connect(series2CB, &QCheckBox::stateChanged,
+                     smoothS2CB, &QPushButton::setEnabled);
+    QObject::connect(series2CB, &QCheckBox::stateChanged,
+                     surfaceGridS2CB, &QPushButton::setEnabled);
+    QObject::connect(series2CB, &QCheckBox::stateChanged,
+                     surfaceS2CB, &QPushButton::setEnabled);
+    QObject::connect(series2CB, &QCheckBox::stateChanged,
+                     series2VisibleCB, &QPushButton::setEnabled);
+
+    QObject::connect(series3CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries3);
+    QObject::connect(series3CB, &QCheckBox::stateChanged,
+                     smoothS3CB, &QPushButton::setEnabled);
+    QObject::connect(series3CB, &QCheckBox::stateChanged,
+                     surfaceGridS3CB, &QPushButton::setEnabled);
+    QObject::connect(series3CB, &QCheckBox::stateChanged,
+                     surfaceS3CB, &QPushButton::setEnabled);
+    QObject::connect(series3CB, &QCheckBox::stateChanged,
+                     series3VisibleCB, &QPushButton::setEnabled);
+
+    QObject::connect(series4CB, &QCheckBox::stateChanged,
+                     modifier, &GraphModifier::toggleSeries4);
+    QObject::connect(series4CB, &QCheckBox::stateChanged,
+                     smoothS4CB, &QPushButton::setEnabled);
+    QObject::connect(series4CB, &QCheckBox::stateChanged,
+                     surfaceGridS4CB, &QPushButton::setEnabled);
+    QObject::connect(series4CB, &QCheckBox::stateChanged,
+                     surfaceS4CB, &QPushButton::setEnabled);
+    QObject::connect(series4CB, &QCheckBox::stateChanged,
+                     series4VisibleCB, &QPushButton::setEnabled);
+#else
     QObject::connect(sqrtSinCB, &QRadioButton::toggled,
                      modifier, &GraphModifier::toggleSqrtSin);
     QObject::connect(planeCB, &QCheckBox::toggled,
@@ -317,6 +498,7 @@ int main(int argc, char *argv[])
                      modifier, &GraphModifier::adjustXCount);
     QObject::connect(gridSliderZ, &QSlider::valueChanged,
                      modifier, &GraphModifier::adjustZCount);
+#endif
     QObject::connect(axisRangeSliderX, &QSlider::valueChanged,
                      modifier, &GraphModifier::adjustXRange);
     QObject::connect(axisRangeSliderZ, &QSlider::valueChanged,
@@ -339,10 +521,12 @@ int main(int argc, char *argv[])
                      modifier, SLOT(changeShadowQuality(int)));
     QObject::connect(selectionMode, SIGNAL(currentIndexChanged(int)),
                      modifier, SLOT(changeSelectionMode(int)));
+#ifndef MULTI_SERIES
     QObject::connect(selectButton, &QPushButton::clicked,
                      modifier, &GraphModifier::selectButtonClicked);
     QObject::connect(flipViewsButton, &QPushButton::clicked,
                      modifier, &GraphModifier::flipViews);
+#endif
     QObject::connect(changeRowButton,&QPushButton::clicked,
                      modifier, &GraphModifier::changeRow);
     QObject::connect(changeRowsButton,&QPushButton::clicked,
@@ -364,15 +548,27 @@ int main(int argc, char *argv[])
     QObject::connect(removeRowButton,&QPushButton::clicked,
                      modifier, &GraphModifier::removeRow);
 
-    modifier->setGridSliderZ(gridSliderZ);
-    modifier->setGridSliderX(gridSliderX);
+#ifdef MULTI_SERIES
+    modifier->setSeries1CB(series1CB);
+    modifier->setSeries2CB(series2CB);
+    modifier->setSeries3CB(series3CB);
+    modifier->setSeries4CB(series4CB);
+    series1CB->setChecked(true);
+    series2CB->setChecked(true);
+    series3CB->setChecked(true);
+    series4CB->setChecked(false);
+#endif
     modifier->setAxisRangeSliderX(axisRangeSliderX);
     modifier->setAxisRangeSliderZ(axisRangeSliderZ);
     modifier->setAxisMinSliderX(axisMinSliderX);
     modifier->setAxisMinSliderZ(axisMinSliderZ);
+#ifndef MULTI_SERIES
+    modifier->setGridSliderZ(gridSliderZ);
+    modifier->setGridSliderX(gridSliderX);
     modifier->toggleGridSliderLock(gridSlidersLockCB->checkState());
     modifier->setSelectionInfoLabel(selectionInfoLabel);
     sqrtSinCB->setChecked(true);
+#endif
     shadowQuality->setCurrentIndex(3);
 
     return app.exec();