HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r757:7dda437b6dfe

Added Icy Blue and High Contrast theme

Tero Ahola -

r757:7dda437b6dfe

parent child

Context file:

r757:7dda437b6dfe

Collapse all files

demos/chartthemes/themewidget.cpp +13 -12

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(100),
                 m_valueCount(11),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti aliasing")),
                 m_animatedComboBox(createAnimationBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 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 = "Item " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
-                themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
+                themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
-                themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
+                themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->setTitle("Area chart");
                 {
                     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);
                     }
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->setTitle("Bar chart");
                 {
                     QBarCategories 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);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->setTitle("Line chart");
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 // pie chart
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 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]) {
                         QPieSlice *slice = series->add(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setPiePosition(hPos, 0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->setTitle("Spline chart");
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->setTitle("Scatter chart");
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(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) {
-                    else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
+                    } else if (theme == QChart::ChartThemeBlueCerulean) {
-                    else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
+                    } else if (theme == QChart::ChartThemeBrownSand) {
-                    else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                    } else if (theme == QChart::ChartThemeBlueNcs) {
-                    else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                    } else if (theme == QChart::ChartThemeHighContrast) {
-                    else {
+                        pal.setColor(QPalette::Window, QRgb(0xffab03));
+                        pal.setColor(QPalette::WindowText, QRgb(0x181818));
+                    } else if (theme == QChart::ChartThemeBlueIcy) {
+                        pal.setColor(QPalette::Window, QRgb(0xcee7f0));
+                        pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                    } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
             }

demos/piechartcustomization/main.cpp +2 -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->brush();
                     m_originalBrush = brush;
                     brush.setColor(brush.color().lighter());
                     setBrush(brush);
                 }
                 void handleHoverLeave()
                 {
                     setBrush(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(new QChart());
                     m_chartView->chart()->setTitle("Piechart customization");
                     m_chartView->chart()->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_series->setLabelsVisible();
                     m_chartView->chart()->addSeries(m_series);
                     connect(m_series, SIGNAL(clicked(QPieSlice*, Qt::MouseButtons)), this, SLOT(handleSliceClicked(QPieSlice*, Qt::MouseButtons)));
                     // 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("Icy", QChart::ChartThemeIcy);
+                    m_themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
-                    m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
+                    m_themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                     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_labelPen = new QPushButton();
                     m_labelPenTool = new PenTool("Label 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 pen", m_labelPen);
                     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_labelPen, SIGNAL(clicked()), m_labelPenTool, SLOT(show()));
                     connect(m_labelPenTool, 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->chart()->setTheme(theme);
                     m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                     if (m_animationsCheckBox->checkState() == Qt::Checked)
                         m_chartView->chart()->setAnimationOptions(QChart::AllAnimations);
                     else
                         m_chartView->chart()->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->setPen(m_penTool->pen());
                     m_slice->setBrush(m_brushTool->brush());
                     m_slice->setLabelPen(m_labelPenTool->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, Qt::MouseButtons buttons)
                 {
                     Q_UNUSED(buttons);
                     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->pen()));
                     m_penTool->setPen(m_slice->pen());
                     // brush
                     m_brush->setText(m_slice->originalBrush().color().name());
                     m_brushTool->setBrush(m_slice->originalBrush());
                     // label
                     m_labelPen->setText(PenTool::name(m_slice->labelPen()));
                     m_labelPenTool->setPen(m_slice->labelPen());
                     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_labelPen;
                 PenTool *m_labelPenTool;
             };
             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/chartview/main.cpp +1 -1

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qscatterseries.h>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qpieseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 //! [1]
                 // Create chart view
                 QChartView *chartView = new QChartView();
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("Simple Line Chart");
                 // Add series to the chart
                 QLineSeries *line = new QLineSeries();
                 line->add(0.0, 0.8);
                 line->add(1.1, 1.1);
                 line->add(2.0, 2.5);
                 chartView->addSeries(line);
                 //! [1]
                 chartView->setChartTitle("\'Scietific\' theme");
                 //! [2]
                 // Change theme
-                chartView->setChartTheme(QChart::ChartThemeScientific);
+                chartView->setChartTheme(QChart::ChartThemeHighContrast);
                 //! [2]
                 chartView->setChartTitle("Simple Pie Chart");
                 //! [3]
                 // Add pie series
                 // ...
                 QPieSeries *pie = new QPieSeries();
                 pie->add(3.4, "slice1");
                 pie->add(6.7, "slice2");
                 chartView->addSeries(pie);
                 //! [3]
                 chartView->setChartTitle("Simple Scatter Chart");
                 //! [4]
                 // Add scatter series
                 // ...
                 QScatterSeries *scatter = new QScatterSeries();
                 for (qreal x(0); x < 100; x += 0.5) {
                     qreal y = rand() % 100;
                     *(scatter) << QPointF(x, y);
                 }
                 chartView->addSeries(scatter);
                 //! [4]
                 chartView->setChartTitle("Simple Bar Chart");
                 //! [5]
                 // ...
                 // Add bar series
                 QStringList barCategory;
                 barCategory << "Jan"
                              << "Feb"
                              << "Mar";
                 QBarSeries *bar = new QBarSeries(barCategory);
                 QBarSet *barSet = new QBarSet("Sales");
                 *barSet << 123.2
                         << 301.3
                         << 285.8;
                 bar->addBarSet(barSet);
                 chartView->addSeries(bar);
                 //! [5]
                 QMainWindow w;
                 w.resize(400, 300);
                 w.setCentralWidget(chartView);
                 w.setWindowFlags(Qt::FramelessWindowHint);
                 w.show();
                 return a.exec();
             }

examples/customcolors/mainwindow.cpp +1 -1

             #include "mainwindow.h"
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qlineseries.h>
             #include <qscatterseries.h>
             #include <qchartaxis.h>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWindow::MainWindow(QWidget *parent)
                 : QMainWindow(parent)
             {
                 // Here's the set of company's colors used throughout the example
                 m_companyColor1 = "#b90020";
                 m_companyColor2 = "#6d0013";
                 m_companyColor3 = "#f5d5d5";
                 m_companyColor4 = "#fcfcfc";
                 resize(400, 300);
                 setWindowFlags(Qt::FramelessWindowHint);
                 // Create chart view
                 //! [4]
                 m_chartView = new QChartView(this);
-                m_chartView->setChartTheme(QChart::ChartThemeScientific);
+                m_chartView->setChartTheme(QChart::ChartThemeHighContrast);
                 //! [4]
                 setCentralWidget(m_chartView);
                 m_chartView->setChartTitle("Custom colors example");
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 // Create line series
                 m_line = new QLineSeries();
                 m_line->add(0.0, 1.1);
                 m_line->add(1.0, 2.3);
                 m_line->add(2.0, 2.1);
                 m_line->add(3.0, 3.3);
                 m_chartView->addSeries(m_line);
                 // Create scatter series with the same data
                 m_scatter = new QScatterSeries();
                 m_scatter->add(m_line->data());
                 m_chartView->addSeries(m_scatter);
                 // Create pie series with different data
                 m_pie = new QPieSeries();
                 m_pie->add(1.1, "1");
                 m_pie->add(2.1, "2");
                 m_pie->add(3.0, "3");
                 m_pie->setPiePosition(0.7, 0.7);
                 m_pie->setPieSize(0.5);
                 m_chartView->addSeries(m_pie);
                 connect(&m_timer, SIGNAL(timeout()), this, SLOT(customize()));
                 m_timer.setInterval(1500);
                 m_timer.setSingleShot(false);
                 m_timer.start();
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::customize()
             {
                 //! [1]
                 // Use a gradient from "color 3" to "color 4" for chart background
                 QLinearGradient chartGradient(0, 0, 0, 300);
                 chartGradient.setColorAt(0.0, m_companyColor3);
                 chartGradient.setColorAt(0.5, m_companyColor4);
                 chartGradient.setColorAt(1.0, m_companyColor3);
                 m_chartView->setChartBackgroundBrush(chartGradient);
                 m_chartView->setBackgroundBrush(m_companyColor4);
                 m_chartView->setChartTitleBrush(m_companyColor1);
                 //! [1]
                 //! [2]
                 QPen color1Pen(m_companyColor1, 4.0);
                 m_chartView->axisX()->setAxisPen(color1Pen);
                 m_chartView->axisY()->setAxisPen(color1Pen);
                 //! [2]
                 //! [3]
                 // Customize pen of the line series
                 m_line->setPen(color1Pen);
                 // Customize pen and brush for the scatter
                 m_scatter->setPen(color1Pen);
                 m_scatter->setBrush(m_companyColor3);
                 // Customize pen and brush for the pie
                 for (int i(0); i < m_pie->slices().count(); i++) {
                     Qt::BrushStyle style = static_cast<Qt::BrushStyle>(i + 1);
                     m_pie->slices().at(i)->setBrush(QBrush(m_companyColor2, style));
                     m_pie->slices().at(i)->setPen(color1Pen);
                 }
                 //! [3]
                 // Calculate new colors to be used on the next update for the series
                 m_companyColor1.setRed((m_companyColor1.red() + 25) % 255);
                 m_companyColor1.setGreen((m_companyColor1.green() + 25) % 255);
                 m_companyColor1.setBlue((m_companyColor1.blue() + 25) % 255);
                 m_companyColor2.setRed((m_companyColor2.red() + 25) % 255);
                 m_companyColor2.setGreen((m_companyColor2.green() + 25) % 255);
                 m_companyColor2.setBlue((m_companyColor2.blue() + 25) % 255);
             }

examples/percentbarchart/main.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QPercentBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Bub");
                 QBarSet *set1 = new QBarSet("Bob");
                 QBarSet *set2 = new QBarSet("Guybrush");
                 QBarSet *set3 = new QBarSet("Larry");
                 QBarSet *set4 = new QBarSet("Zak");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
             //![2]
             //![3]
                 QPercentBarSeries* series = new QPercentBarSeries(categories);
                 series->addBarSet(set0);
                 series->addBarSet(set1);
                 series->addBarSet(set2);
                 series->addBarSet(set3);
                 series->addBarSet(set4);
-            //! [3]
+            //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple precentbarchart example");
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

examples/stackedbarchartdrilldown/main.cpp +1 -1

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <qchartaxis.h>
             #include <QStringList>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //! [1]
             class DrilldownBarSeries : public QStackedBarSeries
             {
                 Q_OBJECT
             public:
                 DrilldownBarSeries(QStringList categories, QObject *parent = 0) : QStackedBarSeries(categories,parent) {}
                 void mapDrilldownSeries(QString category, DrilldownBarSeries* drilldownSeries)
                 {
                     mDrilldownSeries[category] = drilldownSeries;
                 }
                 DrilldownBarSeries* drilldownSeries(QString category)
                 {
                     return mDrilldownSeries[category];
                 }
             public Q_SLOTS:
             private:
                 QMap<QString, DrilldownBarSeries*> mDrilldownSeries;
             };
             //! [1]
             //! [2]
             class DrilldownChart : public QChartView
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QWidget *parent = 0) : QChartView(parent), m_currentSeries(0) {}
                 void changeSeries(QSeries* series)
                 {
                     if (m_currentSeries)
                         removeSeries(m_currentSeries);
                     m_currentSeries = series;
                     addSeries(series);
                     setChartTitle(series->name());
                 }
             public Q_SLOTS:
                 void handleRightClick(QBarSet *barset, QString category)
                 {
                     Q_UNUSED(barset)
                     DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                     changeSeries(series->drilldownSeries(category));
                 }
             private:
                 QSeries* m_currentSeries;
             };
             //! [2]
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
-                drilldownChart->setChartTheme(QChart::ChartThemeIcy);
+                drilldownChart->setChartTheme(QChart::ChartThemeBlueIcy);
                 //! [3]
                 // Define categories
                 QStringList months;
                 months << "May" << "Jun" << "Jul" << "Aug" << "Sep";
                 QStringList weeks;
                 weeks << "week 1" << "week 2" << "week 3" << "week 4";
                 QStringList plants;
                 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
                 //! [3]
                 //! [4]
                 // Create drilldown structure
                 DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
                 seasonSeries->setName("Crop by month - Season");
                 // Each month in season series has drilldown series for weekly data
                 foreach (QString month, months) {
                     // Create drilldown series for every week
                     DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
                     seasonSeries->mapDrilldownSeries(month, weeklySeries);
                     // Drilling down from weekly data brings us back to season data.
                     foreach (QString week, weeks) {
                         weeklySeries->mapDrilldownSeries(week, seasonSeries);
                         weeklySeries->setName(QString("Crop by week - " + month));
                     }
                     // Use right click signal to implement drilldown
                     QObject::connect(weeklySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
                 }
                 // Enable drilldown from season series using right click.
                 QObject::connect(seasonSeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
                 //! [4]
                 //! [5]
                 // Fill monthly and weekly series with data
                 foreach (QString plant, plants) {
                     QBarSet* monthlyCrop = new QBarSet(plant);
                     foreach (QString month, months) {
                         QBarSet* weeklyCrop = new QBarSet(plant);
                         foreach (QString week, weeks ) {
                             *weeklyCrop << (qrand() % 20);
                         }
                         // Get the drilldown series from season series and add crop to it.
                         seasonSeries->drilldownSeries(month)->addBarSet(weeklyCrop);
                         seasonSeries->drilldownSeries(month)->setToolTipEnabled(true);
                         *monthlyCrop << weeklyCrop->total();
                         QObject::connect(weeklyCrop,SIGNAL(clicked(QString)),weeklyCrop,SIGNAL(toggleFloatingValues()));
                     }
                     seasonSeries->addBarSet(monthlyCrop);
                     QObject::connect(monthlyCrop,SIGNAL(clicked(QString)),monthlyCrop,SIGNAL(toggleFloatingValues()));
                 }
                 //! [5]
                 seasonSeries->setToolTipEnabled(true);
                 //! [6]
                 // Show season series in initial view
                 drilldownChart->changeSeries(seasonSeries);
                 drilldownChart->setChartTitle(seasonSeries->name());
                 //! [6]
                 drilldownChart->axisX()->setGridLineVisible(false);
                 window.setCentralWidget(drilldownChart);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

qmlplugin/declarativechart.h +2 -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,
-                    ThemeIcy,
+                    ThemeHighContrast,
-                    ThemeScientific
+                    ThemeBlueIcy
                 };
                 DeclarativeChart(QDeclarativeItem *parent = 0);
                 ~DeclarativeChart();
             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->setTheme((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 +7 -15

             #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 "chartthemeicy_p.h"
+            #include "chartthemehighcontrast_p.h"
-            #include "chartthemescientific_p.h"
+            #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 12)),
                 m_labelFont(QFont("arial", 10)),
                 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::ChartThemeIcy:
+                    case QChart::ChartThemeHighContrast:
-                        return new ChartThemeIcy();
+                        return new ChartThemeHighContrast();
-                    case QChart::ChartThemeScientific:
+                    case QChart::ChartThemeBlueIcy:
-                        return new ChartThemeScientific();
+                        return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
-                QPen pen;
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
+                    chart->setBackgroundBrush(m_chartBackgroundGradient);
-                    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 (data.m_labelPen.isThemed() || force) {
                         data.m_labelPen = QPen(m_titleBrush.color());
                         data.m_labelPen.setThemed(true);
                     }
                     if (data.m_labelFont.isThemed() || force) {
                         data.m_labelFont = m_labelFont;
                         data.m_labelFont.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_labelFont);
                     }
                 }
             }
             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 +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             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 ChartThemeLight
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
-             \value ChartThemeIcy
+             \value ChartThemeHighContrast
-             \value ChartThemeScientific
+             \value ChartThemeBlueIcy
              \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),
             d_ptr(new QChartPrivate(this))
             {
                 d_ptr->m_legend = new QLegend(this);
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 connect(d_ptr->m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),d_ptr->m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(d_ptr->m_dataset,SIGNAL(seriesRemoved(QSeries*)),d_ptr->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 d_ptr->m_presenter;
                 d_ptr->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)
             {
                 d_ptr->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)
             {
                 d_ptr->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()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 d_ptr->createChartBackgroundItem();
                 d_ptr->m_backgroundItem->setBrush(brush);
                 d_ptr->m_backgroundItem->update();
             }
             QBrush QChart::backgroundBrush() const
             {
                 if (!d_ptr->m_backgroundItem) return QBrush();
                 return (d_ptr->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 d_ptr->createChartBackgroundItem();
                 d_ptr->m_backgroundItem->setPen(pen);
                 d_ptr->m_backgroundItem->update();
             }
             QPen QChart::backgroundPen() const
             {
                 if (!d_ptr->m_backgroundItem) return QPen();
                 return d_ptr->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 d_ptr->createChartTitleItem();
                 d_ptr->m_titleItem->setText(title);
                 d_ptr->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 if (d_ptr->m_titleItem)
                 return d_ptr->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)
             {
                 d_ptr->createChartTitleItem();
                 d_ptr->m_titleItem->setFont(font);
                 d_ptr->updateLayout();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->createChartTitleItem();
                 d_ptr->m_titleItem->setBrush(brush);
                 d_ptr->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 if (!d_ptr->m_titleItem) return QBrush();
                 return d_ptr->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa ChartTheme, chartTheme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setChartTheme()
              */
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->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;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut();
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QChartAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the chart
              */
             QChartAxis* QChart::axisY() const
             {
                 return d_ptr->m_dataset->axisY();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend& QChart::legend() const
             {
                 return *d_ptr->m_legend;
             }
             /*!
              Gives ownership of legend to user.
              */
             QLegend* QChart::takeLegend()
             {
                 QLegend* l = d_ptr->m_legend;
                 d_ptr->m_legend = 0;
                 return l;
             }
             /*!
              Gives ownership of legend back to chart. QChart takes ownership of \a legend and deletes existing one
              */
             void QChart::giveLegend(QLegend *legend)
             {
                 if (d_ptr->m_legend) {
                     // Should not happen.
                     qDebug() << "Warning! Giving more than one legend to chart.";
                     delete d_ptr->m_legend;
                 }
                 d_ptr->m_legend = legend;
                 // Reconnect legend, in case not already connected.
                 disconnect(d_ptr->m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),d_ptr->m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 disconnect(d_ptr->m_dataset,SIGNAL(seriesRemoved(QSeries*)),d_ptr->m_legend,SLOT(handleSeriesRemoved(QSeries*)));
                 connect(d_ptr->m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),d_ptr->m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(d_ptr->m_dataset,SIGNAL(seriesRemoved(QSeries*)),d_ptr->m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
                 d_ptr->updateLayout();
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             void QChart::scrollLeft()
             {
                 d_ptr->m_presenter->scroll(-d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollRight()
             {
                 d_ptr->m_presenter->scroll(d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollUp()
             {
                 d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::scrollDown()
             {
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->createChartBackgroundItem();
                 d_ptr->m_backgroundItem->setVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 if (!d_ptr->m_backgroundItem) return false;
                 return d_ptr->m_backgroundItem->isVisible();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *parent):
             q_ptr(parent),
             m_backgroundItem(0),
             m_titleItem(0),
             m_legend(0),
             m_dataset(0),
             m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(q_ptr);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChartPrivate::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(q_ptr);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChartPrivate::updateLegendLayout()
             {
                 int padding = m_presenter->padding();
                 QRectF plotRect = m_rect.adjusted(padding,padding,-padding,-padding);
                 QRectF legendRect;
                 switch (m_legend->preferredLayout())
                 {
                     case QLegend::PreferredLayoutTop: {
                         //        legendRect = plotRect.adjusted(m_padding,0,-m_padding,-m_padding - plotRect.height());
                         legendRect = plotRect.adjusted(0,0,0,-padding - plotRect.height());
                         break;
                     }
                     case QLegend::PreferredLayoutBottom: {
                         legendRect = plotRect.adjusted(padding,padding + plotRect.height(),-padding,0);
                         break;
                     }
                     case QLegend::PreferredLayoutLeft: {
                         legendRect = plotRect.adjusted(0,padding,-padding - plotRect.width(),-padding);
                         break;
                     }
                     case QLegend::PreferredLayoutRight: {
                         legendRect = plotRect.adjusted(padding + plotRect.width(),padding,0,-padding);
                         break;
                     }
                     default: {
                         legendRect = plotRect;
                         break;
                     }
                 }
                 m_legend->setMaximumSize(legendRect.size());
                 m_legend->setPos(legendRect.topLeft());
             }
             void QChartPrivate::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 int padding = m_presenter->padding();
                 int backgroundPadding = m_presenter->backgroundPadding();
                 QRectF rect = m_rect.adjusted(padding,padding,-padding,-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 + padding/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(backgroundPadding,backgroundPadding, -backgroundPadding, -backgroundPadding));
                 }
                 // recalculate legend position
                 if (m_legend) {
                     if (m_legend->parentObject() == q_ptr) {
                         updateLegendLayout();
                     }
                 }
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QSeries>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSeries;
             class QChartAxis;
             class QLegend;
             class QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeLight,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
-                    ChartThemeIcy,
+                    ChartThemeHighContrast,
-                    ChartThemeScientific,
+                    ChartThemeBlueIcy,
                     ChartThemeCount
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QSeries *series, QChartAxis *axisY = 0);
                 void removeSeries(QSeries *series);
                 void removeAllSeries();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() 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;
                 QLegend* takeLegend();
                 void giveLegend(QLegend* legend);
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QChartView;
                 Q_DISABLE_COPY(QChart);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/themes/chartthemeblueicy_p.h ~~src/themes/chartthemeicy_p.h~~ renamed +15 -13

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

src/themes/chartthemehighcontrast_p.h ~~src/themes/chartthemescientific_p.h~~ renamed +16 -14

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

src/themes/themes.pri +2 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             THEMES += \
                 $$PWD/chartthemedefault_p.h \
                 $$PWD/chartthemelight_p.h \
                 $$PWD/chartthemebluecerulean_p.h \
                 $$PWD/chartthemedark_p.h \
                 $$PWD/chartthemebrownsand_p.h \
                 $$PWD/chartthemebluencs_p.h \
-                $$PWD/chartthemeicy_p.h \
+                $$PWD/chartthemehighcontrast_p.h \
-                $$PWD/chartthemescientific_p.h
  No newline at end of file
+                $$PWD/chartthemeblueicy_p.h

test/chartwidgettest/mainwidget.cpp +2 -2

             #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("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
-                chartTheme->addItem("Icy");
+                chartTheme->addItem("High Contrast");
-                chartTheme->addItem("Scientific");
+                chartTheme->addItem("Blue Icy");
                 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);
             }

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