HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r853:9dc445f7b1fb

Removed default theme, now using light as the default

Tero Ahola -

r853:9dc445f7b1fb

parent child

Context file:

r853:9dc445f7b1fb

Collapse all files

demos/chartthemes/themewidget.cpp +1 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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 <QLegend>
             #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(10),
                 m_valueCount(7),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
-                m_antialiasCheckBox(new QCheckBox("Anti aliasing")),
+                m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
                 m_legendComboBox(createLegendBox())
             {
                 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_legendComboBox);
                 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);
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
             }
             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()));
                 connect(m_legendComboBox, 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;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
                         yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         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("High Contrast", QChart::ChartThemeHighContrast);
                 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;
             }
             QComboBox* ThemeWidget::createLegendBox() const
             {
                 QComboBox* legendComboBox = new QComboBox();
                 legendComboBox->addItem("Legend None", -1);
                 legendComboBox->addItem("Legend Top", QLegend::AlignmentTop);
                 legendComboBox->addItem("Legend Bottom", QLegend::AlignmentBottom);
                 legendComboBox->addItem("Legend Left", QLegend::AlignmentLeft);
                 legendComboBox->addItem("Legend Right", QLegend::AlignmentRight);
                 return legendComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Area chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 0;
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
                         if (lowerSeries)
                             upperSeries->append(QPointF(j, lowerSeries->y(i) + data.first.y()));
                         else
                             upperSeries->append(QPointF(j, data.first.y()));
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(area);
                     lowerSeries = upperSeries;
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 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->appendBarSet(set);
                 }
                 chart->addSeries(series);
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     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->append(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->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     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) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         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);
                 }
                 int alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (alignment == -1) {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setVisible(false);
                     }
                 } else {
                     QLegend::Alignments legendAlignment(alignment);
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignmnent(legendAlignment);
                         chartView->chart()->legend()->setVisible(true);
                     }
                 }
             }

demos/piechartcustomization/mainwidget.cpp 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "customslice.h"
             #include "pentool.h"
             #include "brushtool.h"
             #include <QPushButton>
             #include <QComboBox>
             #include <QCheckBox>
             #include <QLabel>
             #include <QGroupBox>
             #include <QDoubleSpinBox>
             #include <QFormLayout>
             #include <QFontDialog>
             #include <QChartView>
             #include <QPieSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget* parent)
                 :QWidget(parent),
                 m_slice(0)
             {
                 // create chart
                 QChart *chart = new QChart;
                 chart->setTitle("Piechart customization");
                 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();
                 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("High Contrast", QChart::ChartThemeHighContrast);
                 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 chart view
                 m_chartView = new QChartView(chart);
                 // 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();
             }
             void MainWidget::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 MainWidget::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 MainWidget::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 MainWidget::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 MainWidget::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 MainWidget::addSlice()
             {
                 *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1));
             }
             void MainWidget::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 MainWidget::removeSlice()
             {
                 if (!m_slice)
                     return;
                 m_series->remove(m_slice);
                 m_slice = 0;
             }
             #include "moc_mainwidget.cpp"

src/chartpresenter.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$
             ** 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 "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
                 m_themeForce(false),
                 m_backgroundPadding(10)
             {
                 createConnections();
-                setTheme(QChart::ChartThemeDefault,false);
+                setTheme(QChart::ChartThemeLight, false);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 QRectF padding = m_chart->padding();
                 rect.adjust(padding.left(), padding.top(), -padding.right(), -padding.bottom());
                 //rewrite zoom stack
                 /*
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 */
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 Axis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	Chart *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarChartItem* bar = new BarChartItem(barSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries,this);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(pieSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart,m_themeForce);
                 m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
                 r.translate(-m_chart->padding().topLeft());
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	QSizeF size = geometry().size();
             	QRectF rect = geometry();
                 rect.translate(-m_chart->padding().topLeft());
                 m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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 "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
-                m_masterFont(QFont("arial", 12)),
+                m_masterFont(QFont("arial", 14)),
                 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::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
-                        return new ChartThemeDefault();
+                        return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
             }
             void ChartTheme::decorate(QLegend* legend,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() || force){
                     legend->setPen(Qt::NoPen);
                 }
                 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)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(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 *s = series->slices().at(i);
                     PieSliceData data = PieSliceData::data(s);
                     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 (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         emit PieSliceData::data(s).emitChangedSignal(s);
                     }
                 }
             }
             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/charttheme_p.h +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$
             ** 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 CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarChartItem;
             class QBarSeries;
             class StackedBarChartItem;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarChartItem;
             class QScatterSeries;
             class ScatterChartItem;
             class PieChartItem;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
-                explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
+                explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart,bool force = true);
                 void decorate(QLegend* legend,bool force = true);
                 void decorate(QBarSeries* series, int index,bool force = true);
                 void decorate(QLineSeries* series, int index,bool force = true);
                 void decorate(QAreaSeries* series, int index,bool force = true);
                 void decorate(QScatterSeries* series, int index,bool force = true);
                 void decorate(QPieSeries* series, int index,bool force = true);
                 void decorate(QSplineSeries* series, int index,bool force = true);
                 void decorate(QChartAxis* axis, bool axisX,bool force = true);
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_chartBackgroundGradient;
                 QFont m_masterFont;
                 QFont m_labelFont;
                 QBrush m_titleBrush;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 QPen m_gridLinePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/qchart.cpp +1 -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 The default theme
-             \value ChartThemeLight
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \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))
             {
                 //setMinimumSize(200,200);
                 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);
                 setMinimumSize(d_ptr->m_padding.left() * 3, d_ptr->m_padding.top() * 3);
                 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;
             }
             QRect QChart::padding() const
             {
                 return d_ptr->m_padding;
             }
             /*!
              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),
             m_padding(QRect(50,50,0,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 legendPadding = m_chart->legend()->padding();
                 int legendPadding = 30;
                 QRectF rect = m_rect;
                 if ((m_legend->attachedToChart()) && (m_legend->isVisible())) {
                     // Reserve some space for legend
                     switch (m_legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         rect.adjust(m_padding.left(),
                                     m_padding.top() + legendPadding,
                                     -m_padding.right(),
                                     -m_padding.bottom());
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         rect.adjust(m_padding.left(),
                                     m_padding.top(),
                                     -m_padding.right(),
                                     -m_padding.bottom() - legendPadding);
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         rect.adjust(m_padding.left() + legendPadding,
                                     m_padding.top(),
                                     -m_padding.right(),
                                     -m_padding.bottom());
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         rect.adjust(m_padding.left(),
                                     m_padding.top(),
                                     -m_padding.right() - legendPadding,
                                     -m_padding.bottom());
                         break;
                     }
                     default: {
                         rect.adjust(m_padding.left(),
                                     m_padding.top(),
                                     -m_padding.right(),
                                     -m_padding.bottom());
                         break;
                     }
                     }
                 } else {
                     rect.adjust(m_padding.left(),
                                 m_padding.top(),
                                 -m_padding.right(),
                                 -m_padding.bottom());
                 }
                 QRectF plotRect = m_rect.adjusted(m_padding.left()
                                                   ,m_padding.top()
                                                   ,-m_padding.right()
                                                   ,-m_padding.bottom());
                 QRectF legendRect;
                 int padding = 0; // TODO: fix this
                 switch (m_legend->alignment())
                 {
                     case QLegend::AlignmentTop: {
                         legendRect = m_rect.adjusted(0,padding,0,-padding - plotRect.height());
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         legendRect = m_rect.adjusted(padding,padding + plotRect.height(),-padding,0);
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         legendRect = m_rect.adjusted(0,padding,-padding - plotRect.width(),-padding);
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         legendRect = m_rect.adjusted(padding + plotRect.width(),padding,0,-padding);
                         break;
                     }
                     default: {
                         legendRect = plotRect;
                         break;
                     }
                 }
                 m_legend->setMaximumSize(legendRect.size());
                 qreal width = legendRect.width() - m_legend->size().width();
                 qreal height = legendRect.height() - m_legend->size().height();
                 QPointF pos = legendRect.topLeft();
                 if (width > 0) {
                     pos.setX(pos.x() + width/2);
                 }
                 if (height > 0) {
                     pos.setY(pos.y() + height/2);
                 }
                 m_legend->setPos(pos);
             }
             void QChartPrivate::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 int padding = m_padding.top();
                 int backgroundPadding = m_presenter->backgroundPadding();
                 // 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->attachedToChart()) && (m_legend->parentObject() == q_ptr)) {
                         updateLegendLayout();
                     }
                 }
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 -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;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
             public:
                 enum ChartTheme {
-                    ChartThemeDefault,
+                    ChartThemeLight = 0,
-                    ChartThemeLight,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     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;
                 QRect padding() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/themes/themes.pri +1 -1

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             THEMES += \
-                $$PWD/chartthemedefault_p.h \
+                $$PWD/chartthemesystem_p.h \
                 $$PWD/chartthemelight_p.h \
                 $$PWD/chartthemebluecerulean_p.h \
                 $$PWD/chartthemedark_p.h \
                 $$PWD/chartthemebrownsand_p.h \
                 $$PWD/chartthemebluencs_p.h \
                 $$PWD/chartthemehighcontrast_p.h \
                 $$PWD/chartthemeblueicy_p.h

src/themes/chartthemedefault_p.h removed 0 -170

NO CONTENT: file was removed

General Comments 0

Write
Preview

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

No TODOs yet

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

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