HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1182:b3b206fa2a47

More model related tests for Pie

Marek Rosa -

r1182:b3b206fa2a47

parent child

Context file:

r1182:b3b206fa2a47

Collapse all files

test/auto/qpieseries/tst_qpieseries.cpp +80 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpiemodelmapper.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QPieSlice*)
             class tst_qpieseries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void append();
                 void insert();
                 void remove();
                 void calculatedValues();
                 void clickedSignal();
                 void hoverSignal();
                 void model();
                 void modelCustomMap();
+                void modelUpdate();
             private:
                 void verifyCalculatedData(const QPieSeries &series, bool *ok);
             private:
             };
             void tst_qpieseries::initTestCase()
             {
                 qRegisterMetaType<QPieSlice*>("QPieSlice*");
             }
             void tst_qpieseries::cleanupTestCase()
             {
             }
             void tst_qpieseries::init()
             {
             }
             void tst_qpieseries::cleanup()
             {
             }
             void tst_qpieseries::construction()
             {
                 // verify default values
                 QPieSeries s;
                 QVERIFY(s.type() == QAbstractSeries::SeriesTypePie);
                 QVERIFY(s.count() == 0);
                 QVERIFY(s.isEmpty());
                 QCOMPARE(s.sum(), 0.0);
                 QCOMPARE(s.horizontalPosition(), 0.5);
                 QCOMPARE(s.verticalPosition(), 0.5);
                 QCOMPARE(s.pieSize(), 0.7);
                 QCOMPARE(s.pieStartAngle(), 0.0);
                 QCOMPARE(s.pieEndAngle(), 360.0);
             }
             void tst_qpieseries::append()
             {
                 QPieSeries s;
                 // append pointer
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.append(slice1));
                 slice1 = new QPieSlice(1, "slice 1");
                 QVERIFY(s.append(slice1));
                 QVERIFY(!s.append(slice1));
                 QCOMPARE(s.count(), 1);
                 // append pointer list
                 QList<QPieSlice *> list;
                 QVERIFY(!s.append(list));
                 list << (QPieSlice *) 0;
                 QVERIFY(!s.append(list));
                 list.clear();
                 list << new QPieSlice(2, "slice 2");
                 list << new QPieSlice(3, "slice 3");
                 QVERIFY(s.append(list));
                 QVERIFY(!s.append(list));
                 QCOMPARE(s.count(), 3);
                 // append operator
                 s << new QPieSlice(4, "slice 4");
                 s << slice1; // fails because already added
                 QCOMPARE(s.count(), 4);
                 // append with params
                 QPieSlice *slice5 = s.append(5, "slice 5");
                 QVERIFY(slice5 != 0);
                 QCOMPARE(slice5->value(), 5.0);
                 QCOMPARE(slice5->label(), QString("slice 5"));
                 QCOMPARE(s.count(), 5);
                 // check slices
                 QVERIFY(!s.isEmpty());
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::insert()
             {
                 QPieSeries s;
                 // insert one slice
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.insert(0, slice1));
                 slice1 = new QPieSlice(1, "slice 1");
                 QVERIFY(!s.insert(-1, slice1));
                 QVERIFY(!s.insert(5, slice1));
                 QVERIFY(s.insert(0, slice1));
                 QVERIFY(!s.insert(0, slice1));
                 QCOMPARE(s.count(), 1);
                 // add some more slices
                 s.append(2, "slice 2");
                 s.append(4, "slice 4");
                 QCOMPARE(s.count(), 3);
                 // insert between slices
                 s.insert(2, new QPieSlice(3, "slice 3"));
                 QCOMPARE(s.count(), 4);
                 // check slices
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::remove()
             {
                 QPieSeries s;
                 // add some slices
                 QPieSlice *slice1 = s.append(1, "slice 1");
                 QPieSlice *slice2 = s.append(2, "slice 2");
                 QPieSlice *slice3 = s.append(3, "slice 3");
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 QCOMPARE(s.count(), 3);
                 // null pointer remove
                 QVERIFY(!s.remove(0));
                 // remove first
                 QVERIFY(s.remove(slice1));
                 QVERIFY(!s.remove(slice1));
                 QCOMPARE(s.count(), 2);
                 QCOMPARE(s.slices().at(0)->label(), slice2->label());
                 // remove all
                 s.clear();
                 QVERIFY(s.isEmpty());
                 QVERIFY(s.slices().isEmpty());
                 QCOMPARE(s.count(), 0);
                 // check that slices were actually destroyed
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_qpieseries::calculatedValues()
             {
                 bool ok;
                 QPieSeries s;
                 // add a slice
                 QPieSlice *slice1 = s.append(1, "slice 1");
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // add some more slices
                 QList<QPieSlice *> list;
                 list << new QPieSlice(2, "slice 2");
                 list << new QPieSlice(3, "slice 3");
                 s.append(list);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // remove a slice
                 s.remove(slice1);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // insert a slice
                 s.insert(0, new QPieSlice(1, "Slice 4"));
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // clear all
                 s.clear();
                 verifyCalculatedData(s, &ok);
             }
             void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
             {
                 *ok = false;
                 qreal sum = 0;
                 foreach (const QPieSlice *slice, series.slices())
                     sum += slice->value();
                 QCOMPARE(series.sum(), sum);
                 qreal startAngle = series.pieStartAngle();
                 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
                 foreach (const QPieSlice *slice, series.slices()) {
                     qreal ratio = slice->value() / sum;
                     qreal sliceSpan = pieAngleSpan * ratio;
                     QCOMPARE(slice->startAngle(), startAngle);
                     QCOMPARE(slice->endAngle(), startAngle + sliceSpan);
                     QCOMPARE(slice->percentage(), ratio);
                     startAngle += sliceSpan;
                 }
                 if (!series.isEmpty())
                     QCOMPARE(series.slices().last()->endAngle(), series.pieEndAngle());
                 *ok = true;
             }
             void tst_qpieseries::clickedSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append(1, "slice 1");
                 series->append(2, "slice 2");
                 series->append(3, "slice 3");
                 QSignalSpy clickSpy1(series, SIGNAL(clicked(QPieSlice*)));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(139, 85)); // inside slice 1
                 TRY_COMPARE(clickSpy1.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy1.at(0).at(0)), s1);
             }
             void tst_qpieseries::hoverSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append(1, "slice 1");
                 series->append(2, "slice 2");
                 series->append(3, "slice 3");
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside the slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(series, SIGNAL(hovered(QPieSlice*,bool)));
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
             }
             void tst_qpieseries::model()
             {
                 QPieSeries *series = new QPieSeries;
+                QChart *chart = new QChart;
+                chart->addSeries(series);
+                QChartView *chartView = new QChartView(chart);
+                chartView->show();
                 QStandardItemModel *stdModel = new QStandardItemModel(0, 2);
                 series->setModel(stdModel);
                 QVERIFY2((series->model()) == stdModel, "Model should be stdModel");
                 int rowCount = 3;
                 for (int row = 0; row < rowCount; ++row) {
                     for (int column = 0; column < 2; column++) {
                         QStandardItem *item = new QStandardItem(row * column);
                         stdModel->setItem(row, column, item);
                     }
                 }
                 // data has been added to the model, but mapper is not set the number of slices should still be 0
                 QVERIFY2(series->slices().count() == 0, "Mapper has not been set, so the number of slices should be 0");
                 // set the mapper
                 QPieModelMapper *mapper = new QPieModelMapper;
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
                 series->setModelMapper(mapper); // this should cause the Pie to get initialized from the model, since there is now both the model and the mapper defined
                 QCOMPARE(series->slices().count(), rowCount);
+                // set the mappings to be outside of the model
+                mapper->setMapLabels(5);
+                mapper->setMapValues(4);
+                QCOMPARE(series->slices().count(), 0); // Mappings are invalid, so the number of slices should be 0
+                // set back to correct ones
+                mapper->setMapValues(0);
+                mapper->setMapLabels(0);
+                QCOMPARE(series->slices().count(), rowCount);
                 // reset the mappings
                 mapper->reset();
                 QCOMPARE(series->slices().count(), 0); // Mappings have been reset and are invalid, so the number of slices should be 0
                 // unset the model and the mapper
                 series->setModel(0);
                 series->setModelMapper(0);
                 QVERIFY(series->model() == 0); // Model should be unset
                 QVERIFY(series->modelMapper() == 0); // Model mapper should be unset
             }
             void tst_qpieseries::modelCustomMap()
             {
                 int rowCount = 12;
-                QStandardItemModel *stdModel = new QStandardItemModel(0, 2);
+                int columnCount = 3;
+                QStandardItemModel *stdModel = new QStandardItemModel(0, 3);
                 for (int row = 0; row < rowCount; ++row) {
                     for (int column = 0; column < 2; column++) {
                         QStandardItem *item = new QStandardItem(row * column);
                         stdModel->setItem(row, column, item);
                     }
                 }
                 QPieSeries *series = new QPieSeries;
+                QChart *chart = new QChart;
+                chart->addSeries(series);
+                QChartView *chartView = new QChartView(chart);
+                chartView->show();
                 series->setModel(stdModel);
                 QPieModelMapper *mapper = new QPieModelMapper;
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
                 series->setModelMapper(mapper);
                 QCOMPARE(series->slices().count(), rowCount);
+                // lets change the orientation to horizontal
+                mapper->setOrientation(Qt::Horizontal);
+                QCOMPARE(series->slices().count(), columnCount);
+                // change it back to vertical
+                mapper->setOrientation(Qt::Vertical);
+                QCOMPARE(series->slices().count(), rowCount);
                 // lets customize the mapping
                 int first = 3;
                 mapper->setFirst(first);
                 QCOMPARE(series->slices().count(), rowCount - first);
                 int count = 7;
                 mapper->setCount(count);
                 QCOMPARE(series->slices().count(), count);
                 first = 9;
                 mapper->setFirst(first);
                 QCOMPARE(series->slices().count(), qMin(count, rowCount - first));
             }
+            void tst_qpieseries::modelUpdate()
+            {
+                int rowCount = 12;
+                int columnCount = 7;
+                QStandardItemModel *stdModel = new QStandardItemModel(0, 3);
+                for (int row = 0; row < rowCount; ++row) {
+                    for (int column = 0; column < 2; column++) {
+                        QStandardItem *item = new QStandardItem(row * column);
+                        stdModel->setItem(row, column, item);
+                    }
+                }
+                QPieSeries *series = new QPieSeries;
+                QChart *chart = new QChart;
+                chart->addSeries(series);
+                QChartView *chartView = new QChartView(chart);
+                chartView->show();
+                series->setModel(stdModel);
+                QPieModelMapper *mapper = new QPieModelMapper;
+                mapper->setMapValues(0);
+                mapper->setMapLabels(0);
+                series->setModelMapper(mapper);
+                stdModel->insertRows(3, 5);
+                QCOMPARE(series->slices().count(), rowCount + 5);
+                stdModel->removeRows(10, 5);
+                QCOMPARE(series->slices().count(), rowCount);
+                // limit the number of slices taken from the model to 12
+                mapper->setCount(rowCount);
+                stdModel->insertRows(3, 5);
+                QCOMPARE(series->slices().count(), rowCount);
+                stdModel->removeRows(0, 10);
+                QCOMPARE(series->slices().count(), rowCount - 5);
+                // change the orientation to horizontal
+                mapper->setOrientation(Qt::Horizontal);
+                QCOMPARE(series->slices().count(), columnCount);
+                stdModel->insertColumns(3, 10);
+                QCOMPARE(series->slices().count(), rowCount); // count is limited to rowCount (12)
+                stdModel->removeColumns(5, 10);
+                QCOMPARE(series->slices().count(), columnCount);
+            }
             QTEST_MAIN(tst_qpieseries)
             #include "tst_qpieseries.moc"

test/tablemodelchart/tablewidget.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QXYModelMapper>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QPieModelMapper>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QBarModelMapper>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             #include <QHeaderView>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
                 //      specialPie(0)
             {
                 setGeometry(1900, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 //    m_tableView->setMinimumHeight(300);
                 m_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 QPushButton* addColumnRightButton = new QPushButton("Add column to the right");
                 connect(addColumnRightButton, SIGNAL(clicked()), this, SLOT(addColumnRight()));
                 QPushButton* removeColumnButton = new QPushButton("Remove column");
                 connect(removeColumnButton, SIGNAL(clicked()), this, SLOT(removeColumn()));
                 QPushButton* specialPieButton = new QPushButton("Test pie");
                 connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 //    QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 //    buttonsLayout->addWidget(spinBoxLabel);
                 //    buttonsLayout->addWidget(m_linesCountSpinBox);
                 //    buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 //    buttonsLayout->addWidget(addColumnRightButton);
                 //    buttonsLayout->addWidget(removeColumnButton);
                     buttonsLayout->addWidget(specialPieButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 m_lineRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                     radioLayout->addWidget(m_splineRadioButton);
                 //    radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 //    radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 2, 0);
                     mainLayout->addLayout(radioLayout, 3, 0);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 1, 1, 2, 1);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
             }
             void TableWidget::addColumnRight()
             {
                 m_model->insertColumns(m_tableView->currentIndex().column() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeColumn()
             {
                 m_model->removeColumns(m_tableView->currentIndex().column(), qMin(m_model->columnCount() - m_tableView->currentIndex().column(), m_linesCountSpinBox->value()));
             }
             void TableWidget::updateChartType(bool toggle)
             {
                 // this if is needed, so that the function is only called once.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     //        specialPie = 0;
                     m_chart->removeAllSeries();
                     m_chart->axisX()->setNiceNumbersEnabled(false);
                     m_chart->axisY()->setNiceNumbersEnabled(false);
                     // renable axes of the chart (pie hides them)
                     // x axis
                     QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     QPen pen;
                     pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         QXYModelMapper *mapper = new QXYModelMapper;
                         mapper->setMapX(0);
                         mapper->setMapY(1);
                         mapper->setFirst(3);
                         mapper->setCount(4);
                         m_series->setModelMapper(mapper);
                         //            m_series->setModelMapping(0,1, Qt::Vertical);
                         //            m_series->setModelMappingRange(3, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 3, 2, 4));
                         // series 2
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         mapper = new QXYModelMapper;
                         mapper->setMapX(3);
                         mapper->setMapY(4);
                         //            mapper->setFirst(3);
                         //            mapper->setCount(4);
                         m_series->setModelMapper(mapper);
                         //            m_series->setModelMapping(2,3, Qt::Vertical);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(3, 0, 2, 1000));
                         // series 3
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         mapper = new QXYModelMapper;
                         mapper->setMapX(5);
                         mapper->setMapY(6);
                         mapper->setFirst(2);
                         mapper->setCount(-1);
                         m_series->setModelMapper(mapper);
                         //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            m_series->setModelMappingRange(2, -1);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(5, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         QXYModelMapper *mapper = new QXYModelMapper;
                         mapper->setMapX(0);
                         mapper->setMapY(1);
                         mapper->setFirst(0);
                         mapper->setCount(-1);
                         m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 2, 1000));
                         // series 2
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         mapper = new QXYModelMapper;
                         mapper->setMapX(2);
                         mapper->setMapY(3);
                         mapper->setFirst(2);
                         mapper->setCount(4);
                         m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 2, 2, 4));
                         // series 3
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         mapper = new QXYModelMapper;
                         mapper->setMapX(4);
                         mapper->setMapY(5);
                         mapper->setFirst(2);
                         mapper->setCount(-1);
                         m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }
                     //        else if (m_scatterRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            // series 1
                     //            m_series = new QScatterSeries;
                     //            m_series->setModel(m_model);
                     //            m_series->setModelMapping(0,1, Qt::Vertical);
                     //            //            m_series->setModelMappingRange(2, 0);
                     //            //        series->setModelMapping(0,1, Qt::Horizontal);
                     //            m_chart->addSeries(m_series);
                     //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                     //            // series 2
                     //            m_series = new QScatterSeries;
                     //            m_series->setModel(m_model);
                     //            m_series->setModelMapping(2,3, Qt::Vertical);
                     //            //            m_series->setModelMappingRange(1, 6);
                     //            //        series->setModelMapping(2,3, Qt::Horizontal);
                     //            m_chart->addSeries(m_series);
                     //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                     //            // series 3
                     //            m_series = new QScatterSeries;
                     //            m_series->setModel(m_model);
                     //            m_series->setModelMapping(4,5, Qt::Vertical);
                     //            //        series->setModelMapping(4,5, Qt::Horizontal);
                     //            m_chart->addSeries(m_series);
                     //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     //        }
                             else if (m_pieRadioButton->isChecked())
                             {
                                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                                 // pie 1
                                 QPieSeries* pieSeries = new QPieSeries;
                                 pieSeries->setModel(m_model);
                                 QPieModelMapper *mapper = new QPieModelMapper;
-                                mapper->setMapValues(1);
+                                mapper->setMapValues(-1);
-                                mapper->setMapLabels(1);
+                                mapper->setMapLabels(-1);
                                 mapper->setFirst(2);
                                 mapper->setCount(5);
                                 pieSeries->setModelMapper(mapper);
                                 pieSeries->setLabelsVisible(true);
                                 pieSeries->setPieSize(0.75);
                     //            pieSeries->setHorizontalPosition(0.2);
                     //            pieSeries->setVerticalPosition(0.3);
                                 m_chart->addSeries(pieSeries);
-                                seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
+            //                    seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                                 m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 5));
                     //            // pie 2
                     //            pieSeries = new QPieSeries;
                     //            pieSeries->setModel(m_model);
                     //            pieSeries->setModelMapping(1,1, Qt::Vertical);
                     //            pieSeries->setModelMappingRange(2, -1);
                     //            pieSeries->setLabelsVisible(true);
                     //            pieSeries->setPieSize(0.35);
                     //            pieSeries->setHorizontalPosition(0.8);
                     //            pieSeries->setVerticalPosition(0.3);
                     //            m_chart->addSeries(pieSeries);
                     //            seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(1, 2, 1, 1000));
                     //            // pie 3
                     //            pieSeries = new QPieSeries;
                     //            pieSeries->setModel(m_model);
                     //            pieSeries->setModelMapping(2,2, Qt::Vertical);
                     //            pieSeries->setLabelsVisible(true);
                     //            pieSeries->setPieSize(0.35);
                     //            pieSeries->setHorizontalPosition(0.5);
                     //            pieSeries->setVerticalPosition(0.75);
                     //            m_chart->addSeries(pieSeries);
                     //            seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                                 //            // special pie
                                 //            specialPie = new QPieSeries;
                                 //            specialPie->append(17, "1");
                                 //            specialPie->append(45, "2");
                                 //            specialPie->append(77, "3");
                                 //            specialPie->append(37, "4");
                                 //            specialPie->append(27, "5");
                                 //            specialPie->append(47, "6");
                                 //            specialPie->setPieSize(0.35);
                                 //            specialPie->setHorizontalPosition(0.8);
                                 //            specialPie->setVerticalPosition(0.75);
                                 //            specialPie->setLabelsVisible(true);
                                 //            m_chart->addSeries(specialPie);
                             }
                     //        else if (m_areaRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            QLineSeries* upperLineSeries = new QLineSeries;
                     //            upperLineSeries->setModel(m_model);
                     //            upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
                     //            //            upperLineSeries->setModelMappingRange(1, 5);
                     //            QLineSeries* lowerLineSeries = new QLineSeries;
                     //            lowerLineSeries->setModel(m_model);
                     //            lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                     //            QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                     //            m_chart->addSeries(areaSeries);
                     //            seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                     //            m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     //        }
                             else if (m_barRadioButton->isChecked())
                             {
                                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                                 QGroupedBarSeries* barSeries = new QGroupedBarSeries();
                                 barSeries->setCategories(QStringList());
                                 barSeries->setModel(m_model);
                                 //            barSeries->setModelMappingRange(2, 5);
             //                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                                 QBarModelMapper *mapper = new QBarModelMapper;
                                 mapper->setMapCategories(5);
                                 mapper->setMapBarBottom(2);
                                 mapper->setMapBarTop(4);
                                 barSeries->setModelMapper(mapper);
                                 m_chart->addSeries(barSeries);
                                 QList<QBarSet*> barsets = barSeries->barSets();
                                 for (int i = 0; i < barsets.count(); i++) {
                                     seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                                     m_model->addMapping(seriesColorHex, QRect(2 + i, 0, 1, 1000));
                                 }
                             }
                             if (!m_barRadioButton->isChecked()) {
                                 m_chart->axisX()->setRange(0, 500);
                                 m_chart->axisY()->setRange(0, 220);
                             }
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             void TableWidget::testPie()
             {
                 m_series->modelMapper()->setMapX(4);
             //    m_tableView->setColumnWidth(10, 250);
                 //    if (specialPie) {
                 //        specialPie->remove(specialPie->slices().at(2));
                 //        //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
                 //        specialPie->append(4, "heloo");
                 //    }
             }
             TableWidget::~TableWidget()
             {
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages