HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r692:339ba14ee2ea

Default theme background, removed extra themes

Tero Ahola -

r692:339ba14ee2ea

parent child

Context file:

r692:339ba14ee2ea

Collapse all files

demos/chartthemes/main.cpp 0 -2

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             #include <qlineseries.h>
             #include <qsplineseries.h>
             #include <qscatterseries.h>
             #include <qareaseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             typedef QPair<QPointF, QString> Data;
             typedef QList<Data> DataList;
             typedef QList<DataList> DataTable;
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0)
                     :QWidget(parent)
                 {
                     // set seed for random stuff
                     qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                     // generate random data
                     int listCount = 3;
                     int valueMax = 100;
                     int valueCount = 11;
                     for (int i(0); i < listCount; i++) {
                         DataList dataList;
                         for (int j(0); j < valueCount; j++) {
                             QPointF value(j + (qreal) rand() / (qreal) RAND_MAX, qrand() % valueMax);
                             QString label = QString::number(i) + ":" + QString::number(j);
                             dataList << Data(value, label);
                         }
                         m_dataTable << dataList;
                     }
                     // create layout
                     QGridLayout* baseLayout = new QGridLayout();
                     // settings layout
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     m_themeComboBox->addItem("Light", QChart::ChartThemeLight);
                     m_themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                     m_themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                     m_themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                     m_themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
-                    m_themeComboBox->addItem("Vanilla", QChart::ChartThemeVanilla);
                     m_themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
-                    m_themeComboBox->addItem("Grayscale", QChart::ChartThemeGrayscale);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
                     connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateTheme()));
                     QCheckBox *antialiasCheckBox = new QCheckBox("Anti aliasing");
                     connect(antialiasCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateAntialiasing(bool)));
                     QCheckBox *animatedCheckBox = new QCheckBox("Animated");
                     connect(animatedCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateAnimations(bool)));
                     QHBoxLayout *settingsLayout = new QHBoxLayout();
                     settingsLayout->addWidget(new QLabel("Theme:"));
                     settingsLayout->addWidget(m_themeComboBox);
                     settingsLayout->addWidget(antialiasCheckBox);
                     settingsLayout->addWidget(animatedCheckBox);
                     settingsLayout->addStretch();
                     baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                     // area chart
                     QChartView *chart = new QChartView();
                     chart->setChartTitle("Area chart");
                     baseLayout->addWidget(chart, 1, 0);
                     {
                         for (int i(0); i < m_dataTable.count(); i++) {
                             QLineSeries *series1 = new QLineSeries(chart);
                             QLineSeries *series2 = new QLineSeries(chart);
                             foreach (Data data, m_dataTable[i]) {
                                 series1->add(data.first);
                                 series2->add(QPointF(data.first.x(), 0.0));
                             }
                             QAreaSeries *area = new QAreaSeries(series1, series2);
                             chart->addSeries(area);
                         }
                     }
                     m_charts << chart;
                     // bar chart
                     chart = new QChartView();
                     chart->setChartTitle("bar chart");
                     baseLayout->addWidget(chart, 1, 1);
                     {
                         QStringList categories;
                         // TODO: categories
                         for (int i(0); i < valueCount; i++)
                             categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                         QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                         for (int i(0); i < m_dataTable.count(); i++) {
                             QBarSet *set = new QBarSet("Set" + QString::number(i));
                             foreach (Data data, m_dataTable[i])
                                 *set << data.first.y();
                             series->addBarSet(set);
                         }
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // line chart
                     chart = new QChartView();
                     chart->setChartTitle("line chart");
                     baseLayout->addWidget(chart, 1, 2);
                     foreach (DataList list, m_dataTable) {
                         QLineSeries *series = new QLineSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // pie chart
                     chart = new QChartView();
                     chart->setChartTitle("pie chart");
                     baseLayout->addWidget(chart, 2, 0);
                     qreal pieSize = 1.0 / m_dataTable.count();
                     for (int i=0; i<m_dataTable.count(); i++) {
                         QPieSeries *series = new QPieSeries(chart);
                         foreach (Data data, m_dataTable[i])
                             series->add(data.first.y(), data.second);
                         qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                         series->setPieSize(pieSize);
                         series->setPiePosition(hPos, 0.5);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // spine chart
                     chart = new QChartView();
                     chart->setChartTitle("spline chart");
                     baseLayout->addWidget(chart, 2, 1);
                     foreach (DataList list, m_dataTable) {
                         QSplineSeries *series = new QSplineSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // scatter chart
                     chart = new QChartView();
                     chart->setChartTitle("scatter chart");
                     baseLayout->addWidget(chart, 2, 2);
                     foreach (DataList list, m_dataTable) {
                         QScatterSeries *series = new QScatterSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     setLayout(baseLayout);
                 }
             public Q_SLOTS:
                 void updateTheme()
                 {
                     QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                     foreach (QChartView *chart, m_charts)
                         chart->setChartTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 void updateAntialiasing(bool enabled)
                 {
                     foreach (QChartView *chart, m_charts)
                         chart->setRenderHint(QPainter::Antialiasing, enabled);
                 }
                 void updateAnimations(bool animated)
                 {
                     QChart::AnimationOptions options = QChart::NoAnimation;
                     if (animated)
                         options = QChart::AllAnimations;
                     foreach (QChartView *chart, m_charts)
                         chart->setAnimationOptions(options);
                 }
             private:
                 QList<QChartView*> m_charts;
                 QComboBox *m_themeComboBox;
                 DataTable m_dataTable;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 MainWidget* widget = new MainWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

demos/piechartcustomization/main.cpp 0 -2

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QPushButton>
             #include <QColorDialog>
             #include <QFontDialog>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class PenTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit PenTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_widthSpinBox = new QDoubleSpinBox();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("NoPen");
                     m_styleCombo->addItem("SolidLine");
                     m_styleCombo->addItem("DashLine");
                     m_styleCombo->addItem("DotLine");
                     m_styleCombo->addItem("DashDotLine");
                     m_styleCombo->addItem("DashDotDotLine");
                     m_capStyleCombo = new QComboBox();
                     m_capStyleCombo->addItem("FlatCap", Qt::FlatCap);
                     m_capStyleCombo->addItem("SquareCap", Qt::SquareCap);
                     m_capStyleCombo->addItem("RoundCap", Qt::RoundCap);
                     m_joinStyleCombo = new QComboBox();
                     m_joinStyleCombo->addItem("MiterJoin", Qt::MiterJoin);
                     m_joinStyleCombo->addItem("BevelJoin", Qt::BevelJoin);
                     m_joinStyleCombo->addItem("RoundJoin", Qt::RoundJoin);
                     m_joinStyleCombo->addItem("SvgMiterJoin", Qt::SvgMiterJoin);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Width", m_widthSpinBox);
                     layout->addRow("Style", m_styleCombo);
                     layout->addRow("Cap style", m_capStyleCombo);
                     layout->addRow("Join style", m_joinStyleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_widthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateWidth(double)));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle(int)));
                     connect(m_capStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateCapStyle(int)));
                     connect(m_joinStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateJoinStyle(int)));
                 }
                 void setPen(QPen pen)
                 {
                     m_pen = pen;
                     m_colorButton->setText(m_pen.color().name());
                     m_widthSpinBox->setValue(m_pen.widthF());
                     m_styleCombo->setCurrentIndex(m_pen.style()); // index matches the enum
                     m_capStyleCombo->setCurrentIndex(m_capStyleCombo->findData(m_pen.capStyle()));
                     m_joinStyleCombo->setCurrentIndex(m_joinStyleCombo->findData(m_pen.joinStyle()));
                 }
                 QPen pen() const
                 {
                     return m_pen;
                 }
                 QString name()
                 {
                     return name(m_pen);
                 }
                 static QString name(const QPen &pen)
                 {
                     return pen.color().name() + ":" + QString::number(pen.widthF());
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_pen.color());
                     dialog.show();
                     dialog.exec();
                     m_pen.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_pen.color().name());
                     emit changed();
                 }
                 void updateWidth(double width)
                 {
                     if (width != m_pen.widthF()) {
                         m_pen.setWidthF(width);
                         emit changed();
                     }
                 }
                 void updateStyle(int style)
                 {
                     if (m_pen.style() != style) {
                         m_pen.setStyle((Qt::PenStyle) style);
                         emit changed();
                     }
                 }
                 void updateCapStyle(int index)
                 {
                     Qt::PenCapStyle capStyle = (Qt::PenCapStyle) m_capStyleCombo->itemData(index).toInt();
                     if (m_pen.capStyle() != capStyle) {
                         m_pen.setCapStyle(capStyle);
                         emit changed();
                     }
                 }
                 void updateJoinStyle(int index)
                 {
                     Qt::PenJoinStyle joinStyle = (Qt::PenJoinStyle) m_joinStyleCombo->itemData(index).toInt();
                     if (m_pen.joinStyle() != joinStyle) {
                         m_pen.setJoinStyle(joinStyle);
                         emit changed();
                     }
                 }
             private:
                 QPen m_pen;
                 QPushButton *m_colorButton;
                 QDoubleSpinBox *m_widthSpinBox;
                 QComboBox *m_styleCombo;
                 QComboBox *m_capStyleCombo;
                 QComboBox *m_joinStyleCombo;
             };
             class BrushTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit BrushTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("Nobrush", Qt::NoBrush);
                     m_styleCombo->addItem("Solidpattern", Qt::SolidPattern);
                     m_styleCombo->addItem("Dense1pattern", Qt::Dense1Pattern);
                     m_styleCombo->addItem("Dense2attern", Qt::Dense2Pattern);
                     m_styleCombo->addItem("Dense3Pattern", Qt::Dense3Pattern);
                     m_styleCombo->addItem("Dense4Pattern", Qt::Dense4Pattern);
                     m_styleCombo->addItem("Dense5Pattern", Qt::Dense5Pattern);
                     m_styleCombo->addItem("Dense6Pattern", Qt::Dense6Pattern);
                     m_styleCombo->addItem("Dense7Pattern", Qt::Dense7Pattern);
                     m_styleCombo->addItem("HorPattern", Qt::HorPattern);
                     m_styleCombo->addItem("VerPattern", Qt::VerPattern);
                     m_styleCombo->addItem("CrossPattern", Qt::CrossPattern);
                     m_styleCombo->addItem("BDiagPattern", Qt::BDiagPattern);
                     m_styleCombo->addItem("FDiagPattern", Qt::FDiagPattern);
                     m_styleCombo->addItem("DiagCrossPattern", Qt::DiagCrossPattern);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Style", m_styleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle()));
                 }
                 void setBrush(QBrush brush)
                 {
                     m_brush = brush;
                     m_colorButton->setText(m_brush.color().name());
                     m_styleCombo->setCurrentIndex(m_brush.style()); // index matches the enum
                 }
                 QBrush brush() const
                 {
                     return m_brush;
                 }
                 QString name()
                 {
                     return name(m_brush);
                 }
                 static QString name(const QBrush &brush)
                 {
                     return brush.color().name();
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_brush.color());
                     dialog.show();
                     dialog.exec();
                     m_brush.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_brush.color().name());
                     emit changed();
                 }
                 void updateStyle()
                 {
                     Qt::BrushStyle style = (Qt::BrushStyle) m_styleCombo->itemData(m_styleCombo->currentIndex()).toInt();
                     if (m_brush.style() != style) {
                         m_brush.setStyle(style);
                         emit changed();
                     }
                 }
             private:
                 QBrush m_brush;
                 QPushButton *m_colorButton;
                 QComboBox *m_styleCombo;
             };
             class CustomSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 CustomSlice(qreal value, QString label)
                     :QPieSlice(value, label)
                 {
                     connect(this, SIGNAL(hoverEnter()), this, SLOT(handleHoverEnter()));
                     connect(this, SIGNAL(hoverLeave()), this, SLOT(handleHoverLeave()));
                 }
             public:
                 QBrush originalBrush()
                 {
                     return m_originalBrush;
                 }
             public Q_SLOTS:
                 void handleHoverEnter()
                 {
                     QBrush brush = this->sliceBrush();
                     m_originalBrush = brush;
                     brush.setColor(brush.color().lighter());
                     setSliceBrush(brush);
                 }
                 void handleHoverLeave()
                 {
                     setSliceBrush(m_originalBrush);
                 }
             private:
                 QBrush m_originalBrush;
             };
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0)
                     :QWidget(parent),
                     m_slice(0)
                 {
                     // create chart
                     m_chartView =  new QChartView();
                     m_chartView->setChartTitle("Piechart customization");
                     m_chartView->setAnimationOptions(QChart::AllAnimations);
                     // create series
                     m_series = new QPieSeries();
                     *m_series << new CustomSlice(10.0, "Slice 1");
                     *m_series << new CustomSlice(20.0, "Slice 2");
                     *m_series << new CustomSlice(30.0, "Slice 3");
                     *m_series << new CustomSlice(40.0, "Slice 4");
                     *m_series << new CustomSlice(50.0, "Slice 5");
                     m_chartView->addSeries(m_series);
                     connect(m_series, SIGNAL(clicked(QPieSlice*)), this, SLOT(handleSliceClicked(QPieSlice*)));
                     // chart settings
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     m_themeComboBox->addItem("Light", QChart::ChartThemeLight);
                     m_themeComboBox->addItem("BlueCerulean", QChart::ChartThemeBlueCerulean);
                     m_themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                     m_themeComboBox->addItem("BrownSand", QChart::ChartThemeBrownSand);
                     m_themeComboBox->addItem("BlueNcs", QChart::ChartThemeBlueNcs);
-                    m_themeComboBox->addItem("Vanilla", QChart::ChartThemeVanilla);
                     m_themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
-                    m_themeComboBox->addItem("Grayscale", QChart::ChartThemeGrayscale);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
                     m_aaCheckBox = new QCheckBox();
                     m_animationsCheckBox = new QCheckBox();
                     m_animationsCheckBox->setCheckState(Qt::Checked);
                     QFormLayout* chartSettingsLayout = new QFormLayout();
                     chartSettingsLayout->addRow("Theme", m_themeComboBox);
                     chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                     chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                     QGroupBox* chartSettings = new QGroupBox("Chart");
                     chartSettings->setLayout(chartSettingsLayout);
                     connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateChartSettings()));
                     connect(m_aaCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                     connect(m_animationsCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                     // series settings
                     m_hPosition = new QDoubleSpinBox();
                     m_hPosition->setMinimum(0.0);
                     m_hPosition->setMaximum(1.0);
                     m_hPosition->setSingleStep(0.1);
                     m_hPosition->setValue(m_series->pieHorizontalPosition());
                     m_vPosition = new QDoubleSpinBox();
                     m_vPosition->setMinimum(0.0);
                     m_vPosition->setMaximum(1.0);
                     m_vPosition->setSingleStep(0.1);
                     m_vPosition->setValue(m_series->pieVerticalPosition());
                     m_sizeFactor = new QDoubleSpinBox();
                     m_sizeFactor->setMinimum(0.0);
                     m_sizeFactor->setMaximum(1.0);
                     m_sizeFactor->setSingleStep(0.1);
                     m_sizeFactor->setValue(m_series->pieSize());
                     m_startAngle = new QDoubleSpinBox();
                     m_startAngle->setMinimum(0.0);
                     m_startAngle->setMaximum(360);
                     m_startAngle->setValue(m_series->pieStartAngle());
                     m_startAngle->setSingleStep(1);
                     m_endAngle = new QDoubleSpinBox();
                     m_endAngle->setMinimum(0.0);
                     m_endAngle->setMaximum(360);
                     m_endAngle->setValue(m_series->pieEndAngle());
                     m_endAngle->setSingleStep(1);
                     QPushButton *addSlice = new QPushButton("Add slice");
                     QPushButton *insertSlice = new QPushButton("Insert slice");
                     QFormLayout* seriesSettingsLayout = new QFormLayout();
                     seriesSettingsLayout->addRow("Horizontal position", m_hPosition);
                     seriesSettingsLayout->addRow("Vertical position", m_vPosition);
                     seriesSettingsLayout->addRow("Size factor", m_sizeFactor);
                     seriesSettingsLayout->addRow("Start angle", m_startAngle);
                     seriesSettingsLayout->addRow("End angle", m_endAngle);
                     seriesSettingsLayout->addRow(addSlice);
                     seriesSettingsLayout->addRow(insertSlice);
                     QGroupBox* seriesSettings = new QGroupBox("Series");
                     seriesSettings->setLayout(seriesSettingsLayout);
                     connect(m_vPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                     connect(m_hPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                     connect(m_sizeFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                     connect(m_startAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                     connect(m_endAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                     connect(addSlice, SIGNAL(clicked()), this, SLOT(addSlice()));
                     connect(insertSlice, SIGNAL(clicked()), this, SLOT(insertSlice()));
                     // slice settings
                     m_sliceName = new QLabel("<click a slice>");
                     m_sliceValue = new QDoubleSpinBox();
                     m_sliceValue->setMaximum(1000);
                     m_sliceLabelVisible = new QCheckBox();
                     m_sliceLabelArmFactor = new QDoubleSpinBox();
                     m_sliceLabelArmFactor->setSingleStep(0.01);
                     m_sliceExploded = new QCheckBox();
                     m_sliceExplodedFactor = new QDoubleSpinBox();
                     m_sliceExplodedFactor->setSingleStep(0.01);
                     m_pen = new QPushButton();
                     m_penTool = new PenTool("Slice pen", this);
                     m_brush = new QPushButton();
                     m_brushTool = new BrushTool("Slice brush", this);
                     m_font = new QPushButton();
                     m_labelArmPen = new QPushButton();
                     m_labelArmPenTool = new PenTool("Label arm pen", this);
                     QPushButton *removeSlice = new QPushButton("Remove slice");
                     QFormLayout* sliceSettingsLayout = new QFormLayout();
                     sliceSettingsLayout->addRow("Selected", m_sliceName);
                     sliceSettingsLayout->addRow("Value", m_sliceValue);
                     sliceSettingsLayout->addRow("Pen", m_pen);
                     sliceSettingsLayout->addRow("Brush", m_brush);
                     sliceSettingsLayout->addRow("Label visible", m_sliceLabelVisible);
                     sliceSettingsLayout->addRow("Label font", m_font);
                     sliceSettingsLayout->addRow("Label arm pen", m_labelArmPen);
                     sliceSettingsLayout->addRow("Label arm length", m_sliceLabelArmFactor);
                     sliceSettingsLayout->addRow("Exploded", m_sliceExploded);
                     sliceSettingsLayout->addRow("Explode distance", m_sliceExplodedFactor);
                     sliceSettingsLayout->addRow(removeSlice);
                     QGroupBox* sliceSettings = new QGroupBox("Slice");
                     sliceSettings->setLayout(sliceSettingsLayout);
                     connect(m_sliceValue, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                     connect(m_pen, SIGNAL(clicked()), m_penTool, SLOT(show()));
                     connect(m_penTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                     connect(m_brush, SIGNAL(clicked()), m_brushTool, SLOT(show()));
                     connect(m_brushTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                     connect(m_font, SIGNAL(clicked()), this, SLOT(showFontDialog()));
                     connect(m_labelArmPen, SIGNAL(clicked()), m_labelArmPenTool, SLOT(show()));
                     connect(m_labelArmPenTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                     connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                     connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                     connect(m_sliceLabelArmFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                     connect(m_sliceExploded, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                     connect(m_sliceExplodedFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                     connect(removeSlice, SIGNAL(clicked()), this, SLOT(removeSlice()));
                     // create main layout
                     QVBoxLayout *settingsLayout = new QVBoxLayout();
                     settingsLayout->addWidget(chartSettings);
                     settingsLayout->addWidget(seriesSettings);
                     settingsLayout->addWidget(sliceSettings);
                     settingsLayout->addStretch();
                     QGridLayout* baseLayout = new QGridLayout();
                     baseLayout->addLayout(settingsLayout, 0, 0);
                     baseLayout->addWidget(m_chartView, 0, 1);
                     setLayout(baseLayout);
                     updateSerieSettings();
                 }
             public Q_SLOTS:
                 void updateChartSettings()
                 {
                     QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                     m_chartView->setChartTheme(theme);
                     m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                     if (m_animationsCheckBox->checkState() == Qt::Checked)
                         m_chartView->setAnimationOptions(QChart::AllAnimations);
                     else
                         m_chartView->setAnimationOptions(QChart::NoAnimation);
                 }
                 void updateSerieSettings()
                 {
                     m_series->setPiePosition(m_hPosition->value(), m_vPosition->value());
                     m_series->setPieSize(m_sizeFactor->value());
                     m_series->setPieStartAngle(m_startAngle->value());
                     m_series->setPieEndAngle(m_endAngle->value());
                 }
                 void updateSliceSettings()
                 {
                     if (!m_slice)
                         return;
                     m_slice->setValue(m_sliceValue->value());
                     m_slice->setSlicePen(m_penTool->pen());
                     m_slice->setSliceBrush(m_brushTool->brush());
                     m_slice->setLabelArmPen(m_labelArmPenTool->pen());
                     m_slice->setLabelVisible(m_sliceLabelVisible->isChecked());
                     m_slice->setLabelArmLengthFactor(m_sliceLabelArmFactor->value());
                     m_slice->setExploded(m_sliceExploded->isChecked());
                     m_slice->setExplodeDistanceFactor(m_sliceExplodedFactor->value());
                 }
                 void handleSliceClicked(QPieSlice* slice)
                 {
                     m_slice = static_cast<CustomSlice*>(slice);
                     // name
                     m_sliceName->setText(slice->label());
                     // value
                     m_sliceValue->blockSignals(true);
                     m_sliceValue->setValue(slice->value());
                     m_sliceValue->blockSignals(false);
                     // pen
                     m_pen->setText(PenTool::name(m_slice->slicePen()));
                     m_penTool->setPen(m_slice->slicePen());
                     // brush
                     m_brush->setText(m_slice->originalBrush().color().name());
                     m_brushTool->setBrush(m_slice->originalBrush());
                     // label
                     m_labelArmPen->setText(PenTool::name(m_slice->labelArmPen()));
                     m_labelArmPenTool->setPen(m_slice->labelArmPen());
                     m_font->setText(slice->labelFont().toString());
                     m_sliceLabelVisible->blockSignals(true);
                     m_sliceLabelVisible->setChecked(slice->isLabelVisible());
                     m_sliceLabelVisible->blockSignals(false);
                     m_sliceLabelArmFactor->blockSignals(true);
                     m_sliceLabelArmFactor->setValue(slice->labelArmLengthFactor());
                     m_sliceLabelArmFactor->blockSignals(false);
                     // exploded
                     m_sliceExploded->blockSignals(true);
                     m_sliceExploded->setChecked(slice->isExploded());
                     m_sliceExploded->blockSignals(false);
                     m_sliceExplodedFactor->blockSignals(true);
                     m_sliceExplodedFactor->setValue(slice->explodeDistanceFactor());
                     m_sliceExplodedFactor->blockSignals(false);
                 }
                 void showFontDialog()
                 {
                     if (!m_slice)
                         return;
                     QFontDialog dialog(m_slice->labelFont());
                     dialog.show();
                     dialog.exec();
                     m_slice->setLabelFont(dialog.currentFont());
                     m_font->setText(dialog.currentFont().toString());
                 }
                 void addSlice()
                 {
                     *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1));
                 }
                 void insertSlice()
                 {
                     if (!m_slice)
                         return;
                     int i = m_series->slices().indexOf(m_slice);
                     m_series->insert(i, new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1)));
                 }
                 void removeSlice()
                 {
                     if (!m_slice)
                         return;
                     m_series->remove(m_slice);
                     m_slice = 0;
                 }
             private:
                 QComboBox *m_themeComboBox;
                 QCheckBox *m_aaCheckBox;
                 QCheckBox *m_animationsCheckBox;
                 QChartView* m_chartView;
                 QPieSeries* m_series;
                 CustomSlice* m_slice;
                 QDoubleSpinBox* m_hPosition;
                 QDoubleSpinBox* m_vPosition;
                 QDoubleSpinBox* m_sizeFactor;
                 QDoubleSpinBox* m_startAngle;
                 QDoubleSpinBox* m_endAngle;
                 QLabel* m_sliceName;
                 QDoubleSpinBox* m_sliceValue;
                 QCheckBox* m_sliceLabelVisible;
                 QDoubleSpinBox* m_sliceLabelArmFactor;
                 QCheckBox* m_sliceExploded;
                 QDoubleSpinBox* m_sliceExplodedFactor;
                 QPushButton *m_brush;
                 BrushTool *m_brushTool;
                 QPushButton *m_pen;
                 PenTool *m_penTool;
                 QPushButton *m_font;
                 QPushButton *m_labelArmPen;
                 PenTool *m_labelArmPenTool;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 MainWidget* widget = new MainWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

examples/piechartdrilldown/main.cpp +1 -1

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
                     :m_drilldownSeries(drilldownSeries),
                     m_prefix(prefix)
                 {
                     setValue(value);
                     setLabelVisible(true);
                     updateLabel();
                     connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
                 }
                 QSeries* drilldownSeries() const { return m_drilldownSeries; }
             public Q_SLOTS:
                 void updateLabel()
                 {
                     QString label = m_prefix;
                     label += " " + QString::number(this->value())+ "e (";
                     label += QString::number(this->percentage()*100, 'f', 1) + "%)";
                     setLabel(label);
                 }
             private:
                 QSeries* m_drilldownSeries;
                 QString m_prefix;
             };
             class DrilldownChart : public QChartView
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QWidget *parent = 0):QChartView(parent), m_currentSeries(0) {}
                 void changeSeries(QSeries* series)
                 {
                     // NOTE: if the series is owned by the chart it will be deleted
                     // here the "window" owns the series...
                     if (m_currentSeries)
                         removeSeries(m_currentSeries);
                     m_currentSeries = series;
                     addSeries(series);
                     setChartTitle(series->title());
                 }
             public Q_SLOTS:
                 void handleSliceClicked(QPieSlice* slice)
                 {
                     DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
                     changeSeries(drilldownSlice->drilldownSeries());
                 }
             private:
                 QSeries* m_currentSeries;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
                 drilldownChart->setRenderHint(QPainter::Antialiasing);
-                drilldownChart->setChartTheme(QChart::ChartThemeVanilla);
+                drilldownChart->setChartTheme(QChart::ChartThemeLight);
                 drilldownChart->setAnimationOptions(QChart::AllAnimations);
                 QPieSeries* yearSeries = new QPieSeries(&window);
                 yearSeries->setTitle("Sales by year - All");
                 QList<QString> months;
                 months << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 QList<QString> names;
                 names << "Jane" << "John" << "Axel" << "Mary" << "Samantha" << "Bob";
                 foreach (QString name, names) {
                     QPieSeries* series = new QPieSeries(&window);
                     series->setTitle("Sales by month - " + name);
                     foreach (QString month, months)
                         *series << new DrilldownSlice(qrand() % 1000, month, yearSeries);
                     QObject::connect(series, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                     *yearSeries << new DrilldownSlice(series->total(), name, series);
                 }
                 QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                 drilldownChart->changeSeries(yearSeries);
                 window.setCentralWidget(drilldownChart);
                 window.resize(800, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

qmlplugin/declarativechart.h 0 -2

             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <QtCore/QtGlobal>
             #include <QDeclarativeItem>
             #include <qchart.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeChart : public QDeclarativeItem
             // TODO: for QTQUICK2: extend QQuickPainterItem instead
             //class DeclarativeChart : public QQuickPaintedItem, public Chart
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
                 Q_PROPERTY(ChartTheme theme READ theme WRITE setTheme)
             public:
                 enum ChartTheme {
                     ThemeDefault,
                     ThemeLight,
                     ThemeBlueCerulean,
                     ThemeDark,
                     ThemeBrownSand,
                     ThemeBlueNcs,
-                    ThemeVanilla,
                     ThemeIcy,
-                    ThemeGrayscale,
                     ThemeScientific
                 };
                 DeclarativeChart(QDeclarativeItem *parent = 0);
             public: // From QDeclarativeItem/QGraphicsItem
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
                 void paint (QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
             public:
                 void setTheme(ChartTheme theme) {m_chart->setChartTheme((QChart::ChartTheme) theme);}
                 ChartTheme theme();
             public:
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECHART_H

src/charttheme.cpp 0 -6

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
-            #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
-            #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont()),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_gridLinePen(QPen(QRgb(0x000000)))
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
-                    case QChart::ChartThemeVanilla:
-                        return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
-                    case QChart::ChartThemeGrayscale:
-                        return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
                 {
                     if (m_backgroundShades == BackgroundShadesNone) {
                         chart->setBackgroundBrush(m_chartBackgroundGradient);
                     }
                     else {
                         chart->setBackgroundBrush(Qt::NoBrush);
                     }
                 }
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
             }
             void ChartTheme::decorate(QLegend* legend,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() || force){
                     //TODO:: legend->setPen();
                 }
                 if (brush == legend->brush() || force) {
                     legend->setBrush(m_chartBackgroundGradient);
                 }
             }
             void ChartTheme::decorate(QAreaSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries* series,int index,bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries* series, int index, bool force)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet*> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     qDebug() << "pos:" << takeAtPos;
                     if (brush == sets.at(i)->brush() || force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setFloatingValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setFloatingValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() || force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries* series, int index, bool force)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice::DataPtr s = series->slices().at(i)->data_ptr();
                     PieSliceData data = s->m_data;
                     if (data.m_slicePen.isThemed() || force) {
                         data.m_slicePen = penColor;
                         data.m_slicePen.setThemed(true);
                     }
                     if (data.m_sliceBrush.isThemed() || force) {
                         data.m_sliceBrush = brushColor;
                         data.m_sliceBrush.setThemed(true);
                     }
                     if (s->m_data != data) {
                         s->m_data = data;
                         emit s->changed();
                     }
                 }
             }
             void ChartTheme::decorate(QSplineSeries* series, int index, bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,bool axisX, bool force)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() || force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() || force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() || force) {
                      if(brush == axis->shadesBrush() || force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() || force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if(force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() || force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() || force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || force){
                         axis->setLabelsFont(m_masterFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (QColor color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +5 -4

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartbackground_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
                 \value ChartThemeDefault Follows the GUI style of the Operating System
-                \value ChartThemeVanilla
+                \value ChartThemeLight
+                \value ChartThemeBlueCerulean
+                \value ChartThemeDark
+                \value ChartThemeBrownSand
+                \value ChartThemeBlueNcs
                 \value ChartThemeIcy
-                \value ChartThemeGrayscale
                 \value ChartThemeScientific
-                \value ChartThemeBlueCerulean
-                \value ChartThemeLight
                 \value ChartThemeCount Not really a theme; the total count of themes.
             */
             /*!
                 \enum QChart::AnimationOption
                 For enabling/disabling animations. Defaults to NoAnimation.
                 \value NoAnimation
                 \value GridAxisAnimations
                 \value SeriesAnimations
                 \value AllAnimations
             */
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             /*!
                 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_legend(new QLegend(this)),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset)),
                 m_padding(50),
                 m_backgroundPadding(10)
             {
                 connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 delete m_presenter;
                 m_presenter=0;
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             QBrush QChart::backgroundBrush() const
             {
                 if(!m_backgroundItem) return QBrush();
                 return m_backgroundItem->brush();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             QPen QChart::backgroundPen() const
             {
                 if(!m_backgroundItem) return QPen();
                 return m_backgroundItem->pen();
             }
             /*!
                 Sets the chart \a title. The description text that is drawn above the chart.
             */
             void QChart::setTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
                 updateLayout();
             }
             /*!
                 Returns the chart title. The description text that is drawn above the chart.
             */
             QString QChart::title() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
                 else
                 return QString();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
                 updateLayout();
             }
             /*!
                 Sets the \a brush used for rendering the title text.
             */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 createChartTitleItem();
                 m_titleItem->setBrush(brush);
                 updateLayout();
             }
             /*!
                 Returns the brush used for rendering the title text.
             */
             QBrush QChart::titleBrush() const
             {
                 if(!m_titleItem) return QBrush();
                 return m_titleItem->brush();
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 m_presenter->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
                 Returns the legend object of the chart. Ownership stays in chart.
             */
             QLegend* QChart::legend() const
             {
                 return m_legend;
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 updateLayout();
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             void QChart::scrollLeft()
             {
                 m_presenter->scroll(-m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollRight()
             {
                 m_presenter->scroll(m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollUp()
             {
                 m_presenter->scroll(0,m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::scrollDown()
             {
             	 m_presenter->scroll(0,-m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::updateLayout()
             {
                 if(!m_rect.isValid()) return;
                 QRectF rect = m_rect.adjusted(m_padding,m_padding, -m_padding, -m_padding);
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + m_padding/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_backgroundPadding,m_backgroundPadding, -m_backgroundPadding, -m_backgroundPadding));
                 }
                 // recalculate legend position
                 if (m_legend) {
                     if (m_legend->parentObject() == this) {
                         m_legend->setMaximumSize(rect.size());
                         m_legend->setPos(rect.topLeft());
                     }
                 }
             }
             int QChart::padding() const
             {
                 return m_padding;
             }
             void QChart::setPadding(int padding)
             {
                 if(m_padding==padding){
                 m_padding = padding;
                 m_presenter->handleGeometryChanged();
                 updateLayout();
                 }
             }
             void QChart::setBackgroundPadding(int padding)
             {
                 if(m_backgroundPadding!=padding){
                 m_backgroundPadding = padding;
                 updateLayout();
                 }
             }
             void QChart::setBackgroundDiameter(int diameter)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setDimeter(diameter);
                 m_backgroundItem->update();
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 if(!m_backgroundItem) return false;
                 return m_backgroundItem->isVisible();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h 0 -2

             #ifndef QCHART_H
             #define QCHART_H
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Axis;
             class QSeries;
             class PlotDomain;
             class BarChartItem;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             class QLegend;
             class ChartBackground;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeLight,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
-                    ChartThemeVanilla,
                     ChartThemeIcy,
-                    ChartThemeGrayscale,
                     ChartThemeScientific,
                     ChartThemeCount
                 };
                 enum  AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                     };
                     Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QSeries* series, QChartAxis* axisY = 0);
                 void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundBrush(const QBrush& brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen& pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
                 QLegend* legend() const;
                 int padding() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
                 void setPadding(int padding);
                 void setBackgroundPadding(int padding);
                 void setBackgroundDiameter(int diameter);
                 void updateLayout();
             private:
                 Q_DISABLE_COPY(QChart)
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 QRectF m_rect;
                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
                 int m_padding;
                 int m_backgroundPadding;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/src.pro +1 -3

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             win32-msvc*: LIBS += User32.lib
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartview.cpp \
                 qseries.cpp \
                 qlegend.cpp \
                 legendmarker.cpp \
                 chartbackground.cpp \
                 chart.cpp
             PRIVATE_HEADERS += \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h \
                 legendmarker_p.h \
                 chartbackground_p.h \
                 chart_p.h
             PUBLIC_HEADERS += \
                 qchart.h \
                 qchartglobal.h \
                 qseries.h \
                 qchartview.h \
                 qlegend.h
             include(animations/animations.pri)
             include(axis/axis.pri)
             include(xychart/xychart.pri)
             include(linechart/linechart.pri)
             include(areachart/areachart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             THEMES += themes/chartthemedefault_p.h \
                 themes/chartthemelight_p.h \
                 themes/chartthemebluecerulean_p.h \
                 themes/chartthemedark_p.h \
                 themes/chartthemebrownsand_p.h \
                 themes/chartthemebluencs_p.h \
                 themes/chartthemeicy_p.h \
-                themes/chartthemegrayscale_p.h \
+                themes/chartthemescientific_p.h
-                themes/chartthemescientific_p.h \
-                themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             #qt public headers
             #this is very primitive and lame parser , TODO: make perl script insted
             !exists($$CHART_BUILD_PUBLIC_HEADER_DIR)
             {
                 system($$QMAKE_MKDIR $$CHART_BUILD_PUBLIC_HEADER_DIR)
             }
             for(file, PUBLIC_HEADERS) {
                 name = $$split(file,'/')
                 name = $$last(name)
                 class = "$$cat($$file)"
                 class = $$find(class,class)
                 !isEmpty(class){
                 class = $$split(class,QTCOMMERCIALCHART_EXPORT)
                 class = $$member(class,1)
                 class = $$split(class,' ')
                 class = $$replace(class,' ','')
                 class = $$member(class,0)
                 win32:{
                     command = "echo $${LITERAL_HASH}include \"$$name\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"$$name\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class
                 system($$command)
                 }
             }
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target public_headers
             install_build_public_headers.name = build_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = buld_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers \
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
                 QMAKE_CXXFLAGS += -Werror
             }

src/themes/chartthemebluecerulean_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBlueCerulean: public ChartTheme
             {
             public:
                 ChartThemeBlueCerulean() : ChartTheme(QChart::ChartThemeBlueCerulean)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0xc7e85b);
                     m_seriesColors << QRgb(0x1cb54f);
                     m_seriesColors << QRgb(0x5cbf9b);
                     m_seriesColors << QRgb(0x009fbf);
                     m_seriesColors << QRgb(0xee7392);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);
                     backgroundGradient.setColorAt(0.0, QRgb(0x056189));
                     backgroundGradient.setColorAt(1.0, QRgb(0x101a31));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0xffffff));
                     m_axisLinePen = QPen(QRgb(0xd6d6d6));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0xffffff));
                     m_gridLinePen = QPen(QRgb(0x84a2b0));
                     m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemebluencs_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBlueNcs: public ChartTheme
             {
             public:
                 ChartThemeBlueNcs() : ChartTheme(QChart::ChartThemeBlueNcs)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x1db0da);
                     m_seriesColors << QRgb(0x1341a6);
                     m_seriesColors << QRgb(0x88d41e);
                     m_seriesColors << QRgb(0xff8e1a);
                     m_seriesColors << QRgb(0x398ca3);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0x404044));
                     m_axisLinePen = QPen(QRgb(0xd6d6d6));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemebrownsand_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBrownSand: public ChartTheme
             {
             public:
                 ChartThemeBrownSand() : ChartTheme(QChart::ChartThemeBrownSand)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0xb39b72);
                     m_seriesColors << QRgb(0xb3b376);
                     m_seriesColors << QRgb(0xc35660);
                     m_seriesColors << QRgb(0x536780);
                     m_seriesColors << QRgb(0x494345);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xf3ece0));
                     backgroundGradient.setColorAt(1.0, QRgb(0xf3ece0));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0x404044));
                     m_axisLinePen = QPen(QRgb(0xb5b0a7));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xd4cec3));
                     m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemedark_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeDark : public ChartTheme
             {
             public:
                 ChartThemeDark() : ChartTheme(QChart::ChartThemeDark)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x38ad6b);
                     m_seriesColors << QRgb(0x3c84a7);
                     m_seriesColors << QRgb(0xeb8817);
                     m_seriesColors << QRgb(0x7b7f8c);
                     m_seriesColors << QRgb(0xbf593e);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);
                     backgroundGradient.setColorAt(0.0, QRgb(0x2e303a));
                     backgroundGradient.setColorAt(1.0, QRgb(0x121218));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0xffffff));
                     m_axisLinePen = QPen(QRgb(0x86878c));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0xffffff));
                     m_gridLinePen = QPen(QRgb(0x86878c));
                     m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemedefault_p.h +35 -12

             #include "charttheme_p.h"
             #ifdef Q_OS_WIN
             #include <windows.h>
             #include <stdio.h>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeDefault: public ChartTheme
             {
             public:
                 ChartThemeDefault() : ChartTheme(QChart::ChartThemeDefault)
                 {
             #ifdef Q_OS_WIN
                     // TODO: use theme specific window frame color as a series base color (it would give more
                     // variation to the base colors in addition to the blue and black used now)
                     // TODO: COLOR_WINDOWTEXT for text color?
                     // TODO: COLOR_INFOTEXT for tooltip text color?
                     // TODO: COLOR_INFOBK for tooltip background color?
                     // First series base color from COLOR_HIGHLIGHT
                     DWORD colorHighlight;
                     colorHighlight = GetSysColor(COLOR_HIGHLIGHT);
                     m_seriesColors.append(QColor(GetRValue(colorHighlight),
                                                  GetGValue(colorHighlight),
                                                  GetBValue(colorHighlight)));
                     // Second series base color from COLOR_WINDOWFRAME
                     DWORD colorWindowFrame;
                     colorWindowFrame = GetSysColor(COLOR_WINDOWFRAME);
                     m_seriesColors.append(QColor(GetRValue(colorWindowFrame),
                                                  GetGValue(colorWindowFrame),
                                                  GetBValue(colorWindowFrame)));
                     // Third series base color from the middle of the COLOR_ACTIVECAPTION /
                     // COLOR_GRADIENTACTIVECAPTION gradient
                     DWORD colorGradientActiveCaptionLeft;
                     colorGradientActiveCaptionLeft = GetSysColor(COLOR_ACTIVECAPTION);
                     DWORD colorGradientActiveCaptionRight;
                     colorGradientActiveCaptionRight = GetSysColor(COLOR_GRADIENTACTIVECAPTION);
                     QLinearGradient g;
                     QColor start = QColor(GetRValue(colorGradientActiveCaptionLeft),
                                           GetGValue(colorGradientActiveCaptionLeft),
                                           GetBValue(colorGradientActiveCaptionLeft));
                     g.setColorAt(0.0, start);
                     QColor end = QColor(GetRValue(colorGradientActiveCaptionRight),
                                           GetGValue(colorGradientActiveCaptionRight),
                                           GetBValue(colorGradientActiveCaptionRight));
                     g.setColorAt(1.0, end);
                     m_seriesColors.append(colorAt(g, 0.5));
                     // Generate gradients from the base colors
                     generateSeriesGradients();
                     // Background fill color from COLOR_WINDOW
                     QLinearGradient backgroundGradient;
                     DWORD colorWindow;
                     colorWindow = GetSysColor(COLOR_WINDOW);
                     backgroundGradient.setColorAt(0.0, QColor(GetRValue(colorWindow),
                                                               GetGValue(colorWindow),
                                                               GetBValue(colorWindow)));
                     backgroundGradient.setColorAt(1.0, QColor(GetRValue(colorWindow),
                                                               GetGValue(colorWindow),
                                                               GetBValue(colorWindow)));
                     // Axes and other
-                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_masterFont = QFont("arial");
-                    m_backgroundShades = BackgroundShadesVertical;
+                    m_axisLinePen = QPen(0xd6d6d6);
+                    m_axisLinePen.setWidth(1);
+                    m_axisLabelBrush = QBrush(QRgb(0x404044));
+                    m_gridLinePen = QPen(QRgb(0xe2e2e2));
+                    m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
             #elif defined(Q_OS_LINUX)
                     // TODO: replace this dummy theme with linux specific theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xe9e9e9));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_masterFont = QFont("arial");
-                    m_backgroundShades = BackgroundShadesVertical;
+                    m_axisLinePen = QPen(0xd6d6d6);
+                    m_axisLinePen.setWidth(1);
+                    m_axisLabelBrush = QBrush(QRgb(0x404044));
+                    m_gridLinePen = QPen(QRgb(0xe2e2e2));
+                    m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
             #elif defined(Q_OS_MAC)
                     // TODO: replace this dummy theme with OSX specific theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xe9e9e9));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_masterFont = QFont("arial");
-                    m_backgroundShades = BackgroundShadesVertical;
+                    m_axisLinePen = QPen(0xd6d6d6);
+                    m_axisLinePen.setWidth(1);
+                    m_axisLabelBrush = QBrush(QRgb(0x404044));
+                    m_gridLinePen = QPen(QRgb(0xe2e2e2));
+                    m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
             #else
                     // TODO: replace this dummy theme with generic (not OS specific) theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xafafaf));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
-                    m_backgroundGradient = backgroundGradient;
+                    m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_masterFont = QFont("arial");
-                    m_backgroundShades = BackgroundShadesVertical;
+                    m_axisLinePen = QPen(0xd6d6d6);
+                    m_axisLinePen.setWidth(1);
+                    m_axisLabelBrush = QBrush(QRgb(0x404044));
+                    m_gridLinePen = QPen(QRgb(0xe2e2e2));
+                    m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
             #endif
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemeicy_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeIcy: public ChartTheme
             {
             public:
                 ChartThemeIcy() : ChartTheme(QChart::ChartThemeIcy)
                 {
                     // Series
                     m_seriesColors << QRgb(0x0d2673);
                     m_seriesColors << QRgb(0x2685bf);
                     m_seriesColors << QRgb(0x3dadd9);
                     m_seriesColors << QRgb(0x62c3d9);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xebebeb));
                     backgroundGradient.setColorAt(1.0, QRgb(0xf8f9fb));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_axisLinePen = QPen(QRgb(0x0f0f0f));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
                     m_gridLinePen = QPen(QRgb(0x0f0f0f));
                     m_gridLinePen.setWidth(2);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemelight_p.h +1 0

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeLight: public ChartTheme
             {
             public:
                 ChartThemeLight() : ChartTheme(QChart::ChartThemeLight)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x209fdf);
                     m_seriesColors << QRgb(0x99ca53);
                     m_seriesColors << QRgb(0xf6a625);
                     m_seriesColors << QRgb(0x6d5fd5);
                     m_seriesColors << QRgb(0xbf593e);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_masterFont = QFont("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
+                    m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemescientific_p.h +2 -2

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeScientific: public ChartTheme
             {
             public:
                 ChartThemeScientific() : ChartTheme(QChart::ChartThemeScientific)
                 {
                     // Series
                     m_seriesColors << QRgb(0xFFAD00);
                     m_seriesColors << QRgb(0x596A75);
                     m_seriesColors << QRgb(0x202020);
                     m_seriesColors << QRgb(0x474747);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xfffefc));
                     backgroundGradient.setColorAt(1.0, QRgb(0xfffefc));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
                     m_axisLinePen = QPen(QRgb(0x0f0f0f));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
-                    m_backgroundShadesBrush = QBrush(QColor(0xff, 0xad, 0x00, 0x50));
-                    m_backgroundShades = BackgroundShadesHorizontal;
                     m_gridLinePen = QPen(QRgb(0x0f0f0f));
                     m_gridLinePen.setWidth(2);
+                    m_backgroundShadesBrush = QBrush(QColor(0xff, 0xad, 0x00, 0x50));
+                    m_backgroundShades = BackgroundShadesHorizontal;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

test/chartwidgettest/mainwidget.cpp +5 -3

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include <qpieseries.h>
             #include <qscatterseries.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chartView(0)
             {
                 m_chartView = new QChartView(this);
                 m_chartView->setRubberBandPolicy(QChartView::HorizonalRubberBand);
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 // Add layouts and the chart widget to the main layout
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
-                chartTheme->addItem("Vanilla");
+                chartTheme->addItem("Light");
+                chartTheme->addItem("Blue Cerulean");
+                chartTheme->addItem("Dark");
+                chartTheme->addItem("Brown Sand");
+                chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("Icy");
-                chartTheme->addItem("Grayscale");
                 chartTheme->addItem("Scientific");
-                chartTheme->addItem("Unnamed1");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
                 connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString, int, int, QString, bool)),
                             this, SLOT(addSeries(QString, int, int, QString, bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         for (int i(0); i < column.count(); i++) {
                             series->add(i, column.at(i));
                         }
                         m_chartView->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++) {
                             lineSeries->add(i, column.at(i));
                         }
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         m_chartView->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         for (int i(0); i < column.count(); i++) {
                             (*series) << QPointF(i, column.at(i));
                         }
                         m_chartView->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++) {
                             series->add(column.at(i), labels.at(i));
                         }
                         m_chartView->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
                     QBarSeries* series = 0;
                     if (seriesName == "Bar")
                         series = new QBarSeries(category, this);
                     else if (seriesName == "Stacked bar")
                         series = new QStackedBarSeries(category, this);
                     else
                         series = new QPercentBarSeries(category, this);
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++) {
                             *set << column.at(i);
                         }
                         series->addBarSet(set);
                     }
                     // TODO: new implementation of setFloatingValuesEnabled with signals
                     //series->setFloatingValuesEnabled(true);
                     series->setToolTipEnabled(true);
                     m_chartView->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++) {
                             series->add(i, column.at(i));
                         }
                         m_chartView->addSeries(series);
                     }
                 }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chartView->setChartTheme((QChart::ChartTheme) themeIndex);
                 //TODO: remove this hack. This is just to make it so that theme change is seen immediately.
                 QSize s = size();
                 s.setWidth(s.width()+1);
                 resize(s);
             }

src/themes/chartthemegrayscale_p.h removed 0 -33

NO CONTENT: file was removed

src/themes/chartthemevanilla_p.h removed 0 -34

NO CONTENT: file was removed

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