HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2099:dacd8b696e6b

coding style fixes for demos

Jani Honkonen -

r2099:dacd8b696e6b

parent child

Context file:

r2099:dacd8b696e6b

Expand all files

demos/chartinteractions/chart.cpp +13 -13

             void Chart::setPointClicked(bool clicked)
             {
-               m_clicked = clicked;
+                m_clicked = clicked;
             }
             void Chart::handlePointMove(const QPoint &point)
                     //Map the point clicked from the ChartView
                     //to the area occupied by the chart.
                     QPoint mappedPoint = point;
-                    mappedPoint.setX(point.x()-this->plotArea().x());
+                    mappedPoint.setX(point.x() - this->plotArea().x());
-                    mappedPoint.setY(point.y()-this->plotArea().y());
+                    mappedPoint.setY(point.y() - this->plotArea().y());
                     //Get the x- and y axis to be able to convert the mapped
                     //coordinate point to the charts scale.
-                    QAbstractAxis * axisx = this->axisX();
+                    QAbstractAxis *axisx = this->axisX();
-                    QValueAxis* haxis = 0;
+                    QValueAxis *haxis = 0;
                     if (axisx->type() == QAbstractAxis::AxisTypeValue)
-                        haxis = qobject_cast<QValueAxis*>(axisx);
+                        haxis = qobject_cast<QValueAxis *>(axisx);
-                    QAbstractAxis * axisy = this->axisY();
+                    QAbstractAxis *axisy = this->axisY();
-                    QValueAxis* vaxis = 0;
+                    QValueAxis *vaxis = 0;
                     if (axisy->type() == QAbstractAxis::AxisTypeValue)
-                        vaxis = qobject_cast<QValueAxis*>(axisy);
+                        vaxis = qobject_cast<QValueAxis *>(axisy);
                     if (haxis && vaxis) {
                         //Calculate the "unit" between points on the x
                         //y axis.
-                        double xUnit = this->plotArea().width()/haxis->max();
+                        double xUnit = this->plotArea().width() / haxis->max();
-                        double yUnit = this->plotArea().height()/vaxis->max();
+                        double yUnit = this->plotArea().height() / vaxis->max();
                         //Convert the mappedPoint to the actual chart scale.
-                        double x = mappedPoint.x()/xUnit;
+                        double x = mappedPoint.x() / xUnit;
-                        double y = vaxis->max() - mappedPoint.y()/yUnit;
+                        double y = vaxis->max() - mappedPoint.y() / yUnit;
                         //Replace the old point with the new one.
                         m_series->replace(m_movingPoint, QPointF(x, y));

demos/chartinteractions/main.cpp +3 -3

             {
                 QApplication a(argc, argv);
-                QLineSeries* series = new QLineSeries();
+                QLineSeries *series = new QLineSeries();
                 series->append(0, 6);
                 series->append(1, 3);
                 series->append(10, 5);
                 *series << QPointF(11, 1) << QPointF(13, 3) << QPointF(17, 6) << QPointF(18, 3) << QPointF(20, 2);
-                Chart* chart = new Chart(0, 0, series);
+                Chart *chart = new Chart(0, 0, series);
                 chart->legend()->hide();
                 chart->addSeries(series);
                 QPen p = series->pen();
                 QObject::connect(series, SIGNAL(clicked(QPointF)), chart, SLOT(clickPoint(QPointF)));
-                ChartView* chartView = new ChartView(chart);
+                ChartView *chartView = new ChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 QMainWindow window;

demos/chartthemes/main.cpp +1 -1

             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                ThemeWidget* widget = new ThemeWidget();
+                ThemeWidget *widget = new ThemeWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();

demos/chartthemes/themewidget.cpp +31 -29

             #include <QTime>
             #include <QBarCategoryAxis>
-            ThemeWidget::ThemeWidget(QWidget* parent) :
+            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_dataTable(generateRandomData(m_listCount, m_valueMax, m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
             {
                 connectSignals();
                 // create layout
-                QGridLayout* baseLayout = new QGridLayout();
+                QGridLayout *baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
-            DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
+            DataTable ThemeWidget::generateRandomData(int listCount, int valueMax, int valueCount) const
             {
                 DataTable dataTable;
                     DataList dataList;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
-                        yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
+                        yValue = yValue + (qreal)(qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         QString label = "Slice " + QString::number(i) + ":" + QString::number(j);
                 return dataTable;
             }
-            QComboBox* ThemeWidget::createThemeBox() const
+            QComboBox *ThemeWidget::createThemeBox() const
             {
                 // settings layout
-                QComboBox* themeComboBox = new QComboBox();
+                QComboBox *themeComboBox = new QComboBox();
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 return themeComboBox;
             }
-            QComboBox* ThemeWidget::createAnimationBox() const
+            QComboBox *ThemeWidget::createAnimationBox() const
             {
                 // settings layout
-                QComboBox* animationComboBox = new QComboBox();
+                QComboBox *animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 return animationComboBox;
             }
-            QComboBox* ThemeWidget::createLegendBox() const
+            QComboBox *ThemeWidget::createLegendBox() const
             {
-                QComboBox* legendComboBox = new QComboBox();
+                QComboBox *legendComboBox = new QComboBox();
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 return legendComboBox;
             }
-            QChart* ThemeWidget::createAreaChart() const
+            QChart *ThemeWidget::createAreaChart() const
             {
                 QChart *chart = new QChart();
             //    chart->axisX()->setNiceNumbersEnabled(true);
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
-                        if (lowerSeries){
+                        if (lowerSeries) {
                             const QList<QPointF>& points = lowerSeries->points();
                             upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
-                        }else
+                        } else {
                             upperSeries->append(QPointF(j, data.first.y()));
+                        }
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                 return chart;
             }
-            QChart* ThemeWidget::createBarChart(int valueCount) const
+            QChart *ThemeWidget::createBarChart(int valueCount) const
             {
                 Q_UNUSED(valueCount);
-                QChart* chart = new QChart();
+                QChart *chart = new QChart();
                 chart->setTitle("Bar chart");
-                QStackedBarSeries* series = new QStackedBarSeries(chart);
+                QStackedBarSeries *series = new QStackedBarSeries(chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                 return chart;
             }
-            QChart* ThemeWidget::createLineChart() const
+            QChart *ThemeWidget::createLineChart() const
             {
-                QChart* chart = new QChart();
+                QChart *chart = new QChart();
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 return chart;
             }
-            QChart* ThemeWidget::createPieChart() const
+            QChart *ThemeWidget::createPieChart() const
             {
-                QChart* chart = new QChart();
+                QChart *chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 return chart;
             }
-            QChart* ThemeWidget::createSplineChart() const
+            QChart *ThemeWidget::createSplineChart() const
-            { // spine chart
-                QChart* chart = new QChart();
+                // spine chart
+                QChart *chart = new QChart();
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 return chart;
             }
-            QChart* ThemeWidget::createScatterChart() const
+            QChart *ThemeWidget::createScatterChart() const
-            { // scatter chart
-                QChart* chart = new QChart();
+                // scatter chart
+                QChart *chart = new QChart();
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
-                    foreach (QChartView *chartView, m_charts) {
+                    foreach (QChartView *chartView, m_charts)
                         chartView->chart()->legend()->hide();
                 } else {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignment(alignment);

demos/chartthemes/themewidget.h +11 -11

                 void updateUI();
             private:
-                DataTable generateRandomData(int listCount,int valueMax,int valueCount) const;
+                DataTable generateRandomData(int listCount, int valueMax, int valueCount) const;
-                QComboBox* createThemeBox() const;
+                QComboBox *createThemeBox() const;
-                QComboBox* createAnimationBox() const;
+                QComboBox *createAnimationBox() const;
-                QComboBox* createLegendBox() const;
+                QComboBox *createLegendBox() const;
                 void connectSignals();
-                QChart* createAreaChart() const;
+                QChart *createAreaChart() const;
-                QChart* createBarChart(int valueCount) const;
+                QChart *createBarChart(int valueCount) const;
-                QChart* createPieChart() const;
+                QChart *createPieChart() const;
-                QChart* createLineChart() const;
+                QChart *createLineChart() const;
-                QChart* createSplineChart() const;
+                QChart *createSplineChart() const;
-                QChart* createScatterChart() const;
+                QChart *createScatterChart() const;
             private:
                 int m_listCount;
                 int m_valueMax;
                 int m_valueCount;
-                QList<QChartView*> m_charts;
+                QList<QChartView *> m_charts;
                 DataTable m_dataTable;
                 QComboBox *m_themeComboBox;

demos/chartviewer/charts.h +23 -28

             class Chart
             {
             public:
-                virtual ~Chart(){};
+                virtual ~Chart() {};
-                virtual QChart* createChart(const DataTable& table) = 0;
+                virtual QChart *createChart(const DataTable &table) = 0;
                 virtual QString name() = 0;
                 virtual QString category() = 0;
                 virtual QString subCategory() = 0;
             namespace Charts
             {
-            typedef QList<Chart*> ChartList;
+                typedef QList<Chart *> ChartList;
-            inline ChartList& chartList()
+                inline ChartList &chartList()
+                {
-                static ChartList list;
+                    static ChartList list;
-                return list;
+                    return list;
-            inline bool findChart(Chart* chart)
-                ChartList& list = chartList();
-                if (list.contains(chart)) {
-                    return true;
                 }
-                foreach (Chart* item, list) {
-                    if (item->name() == chart->name() && item->category() == chart->category() && item->subCategory() == chart->subCategory()) {
+                inline bool findChart(Chart *chart)
+                {
+                    ChartList &list = chartList();
+                    if (list.contains(chart))
                         return true;
+                    foreach (Chart *item, list) {
+                        if (item->name() == chart->name() && item->category() == chart->category() && item->subCategory() == chart->subCategory())
+                            return true;
                     }
+                    return false;
                 }
-                return false;
-            inline void addChart(Chart* chart)
+                inline void addChart(Chart *chart)
+                {
-                ChartList& list = chartList();
+                    ChartList &list = chartList();
-                if (!findChart(chart)) {
+                    if (!findChart(chart))
-                    list.append(chart);
+                        list.append(chart);
                 }
             }
             template <class T>
             class ChartWrapper
             {
             public:
                 QSharedPointer<T> chart;
-                ChartWrapper() : chart(new T)
+                ChartWrapper() : chart(new T) { Charts::addChart(chart.data()); }
-                    Charts::addChart(chart.data());
             };
             #define DECLARE_CHART(chartType) static ChartWrapper<chartType> chartType;

demos/chartviewer/charts/axis/categoryaxis.cpp +27 -28

@@ -30,39 +30,38 public:
30	QString category() { return QObject::tr("Axis"); }	30	QString category() { return QObject::tr("Axis"); }
31	QString subCategory() { return QString::null; }	31	QString subCategory() { return QString::null; }
32		32
33	QChart* createChart(const DataTable& table) {	33	QChart *createChart(const DataTable &table)
		34	{
		35	QChart *chart = new QChart();
		36	chart->setTitle("Category X , Category Y ");
34		37
35	QChart* chart = new QChart();	38	QString name("Series ");
36	chart->setTitle("Category X , Category Y ");	39	int nameIndex = 0;
		40	foreach (DataList list, table) {
		41	QLineSeries *series = new QLineSeries(chart);
		42	foreach(Data data, list)
		43	series->append(data.first);
		44	series->setName(name + QString::number(nameIndex));
		45	nameIndex++;
		46	chart->addSeries(series);
		47	}
37		48
38	QString name("Series ");	49	QCategoryAxis *axisX = new QCategoryAxis;
39	int nameIndex = 0;	50	axisX->append("low", 5);
40	foreach (DataList list, table) {	51	axisX->append("avg.", 12);
41	QLineSeries *series = new QLineSeries(chart);	52	axisX->append("high", 19);
42	foreach (Data data, list)	53	axisX->setRange(0, 20);
43	series->append(data.first);	54	chart->setAxisX(axisX, chart->series().at(0));
44	series->setName(name + QString::number(nameIndex));
45	nameIndex++;
46	chart->addSeries(series);
47	}
48		55
49	QCategoryAxis *axisX = new QCategoryAxis;	56	QCategoryAxis *axisY = new QCategoryAxis;
50	~~axisX~~->append("~~low~~", 5);	57	axisY->append("cheap", 5);
51	~~axisX~~->append("~~avg.~~", 12);	58	axisY->append("fair", 12);
52	~~axisX~~->append("~~high~~", 19);	59	axisY->append("pricy", 20);
53	~~axisX~~->setRange(0, 20);	60	axisY->setRange(0, 20);
54	chart->setAxisX(axisX, chart->series().at(0));	61	chart->setAxisY(axisY, chart->series().at(0));
55		62
56	QCategoryAxis *axisY = new QCategoryAxis;	63	return chart;
57	axisY->append("cheap", 5);
58	axisY->append("fair", 12);
59	axisY->append("pricy", 20);
60	axisY->setRange(0, 20);
61	chart->setAxisY(axisY, chart->series().at(0));
62
63	return chart;
64	}	64	}
65
66	};	65	};
67		66
68	DECLARE_CHART(CategoryLineChart)	67	DECLARE_CHART(CategoryLineChart)

demos/chartviewer/charts/axis/valueaxis.cpp +22 -23

@@ -31,30 +31,29 public:
31	QString category() { return QObject::tr("Axis"); }	31	QString category() { return QObject::tr("Axis"); }
32	QString subCategory() { return QString::null; }	32	QString subCategory() { return QString::null; }
33		33
34	QChart* createChart(const DataTable& table) {	34	QChart *createChart(const DataTable &table)
35		35	{
36	QChart* chart = new QChart();	36	QChart *chart = new QChart();
37	chart->setTitle("Value X , Value Y");	37	chart->setTitle("Value X , Value Y");
38		38
39	QString name("Series ");	39	QString name("Series ");
40	int nameIndex = 0;	40	int nameIndex = 0;
41	foreach (DataList list, table) {	41	foreach (DataList list, table) {
42	QLineSeries *series = new QLineSeries(chart);	42	QLineSeries *series = new QLineSeries(chart);
43	foreach (Data data, list)	43	foreach (Data data, list)
44	series->append(data.first);	44	series->append(data.first);
45	series->setName(name + QString::number(nameIndex));	45	series->setName(name + QString::number(nameIndex));
46	nameIndex++;	46	nameIndex++;
47	chart->addSeries(series);	47	chart->addSeries(series);
48	}	48	}
49		49
50	chart->createDefaultAxes();	50	chart->createDefaultAxes();
51	QValueAxis* axis = new QValueAxis();	51	QValueAxis *axis = new QValueAxis();
52	foreach (QAbstractSeries* series,chart->series())	52	foreach (QAbstractSeries *series, chart->series())
53	chart->setAxisX(axis,series);	53	chart->setAxisX(axis, series);
54		54
55	return chart;	55	return chart;
56	}	56	}
57
58	};	57	};
59		58
60	DECLARE_CHART(ValueAxis);	59	DECLARE_CHART(ValueAxis);

demos/chartviewer/charts/barseries/horizontalbarchart.cpp +4 -8

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Horizontal"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
+                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Horizontal bar chart");
+                    QHorizontalBarSeries *series = new QHorizontalBarSeries(chart);
-                    QHorizontalBarSeries* series = new QHorizontalBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(HorizontalBarChart)

demos/chartviewer/charts/barseries/horizontalpercentbarchart.cpp +3 -7

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Horizontal"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Horizontal percent chart");
+                    QHorizontalPercentBarSeries *series = new QHorizontalPercentBarSeries(chart);
-                    QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(HorizontalPercentBarChart)

demos/chartviewer/charts/barseries/horizontalstackedbarchart.cpp +3 -7

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Horizontal"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Horizontal stacked chart");
+                    QHorizontalStackedBarSeries *series = new QHorizontalStackedBarSeries(chart);
-                    QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(HorizontalStackedBarChart)

demos/chartviewer/charts/barseries/verticalbarchart.cpp +3 -7

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Vertical"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Vertical bar chart");
+                    QBarSeries *series = new QBarSeries(chart);
-                    QBarSeries* series = new QBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(VerticalBarChart)

demos/chartviewer/charts/barseries/verticalpercentbarchart.cpp +3 -7

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Vertical"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Stacked bar chart");
+                    QPercentBarSeries *series = new QPercentBarSeries(chart);
-                    QPercentBarSeries* series = new QPercentBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(VerticalPercentBarChart)

demos/chartviewer/charts/barseries/verticalstackedbarchart.cpp +3 -7

                 QString category()  { return QObject::tr("BarSeries"); }
                 QString subCategory() { return QObject::tr("Vertical"); }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Stacked bar chart");
+                    QStackedBarSeries *series = new QStackedBarSeries(chart);
-                    QStackedBarSeries* series = new QStackedBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(VerticalStackedBarChart)

demos/chartviewer/charts/font/font.cpp +49 -45

             class FontChart: public Chart
             {
             public:
-                FontChart(int fontSize):m_fontSize(fontSize){};
+                FontChart(int fontSize): m_fontSize(fontSize) {};
                 QString name() { return QObject::tr("Font") + " " + QString::number(m_fontSize); }
                 QString category()  { return QObject::tr("Font"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table) {
+                QChart *createChart(const DataTable &table)
+                {
-                       QChart* chart = new QChart();
+                    QChart *chart = new QChart();
-                       chart->setTitle("Font size " + QString::number(m_fontSize));
+                    chart->setTitle("Font size " + QString::number(m_fontSize));
+                    QString name("Series ");
-                       QString name("Series ");
+                    int nameIndex = 0;
-                       int nameIndex = 0;
+                    foreach (DataList list, table) {
-                       foreach (DataList list, table) {
+                        QLineSeries *series = new QLineSeries(chart);
-                           QLineSeries *series = new QLineSeries(chart);
+                        foreach (Data data, list)
-                           foreach (Data data, list)
+                            series->append(data.first);
-                               series->append(data.first);
+                        series->setName(name + QString::number(nameIndex));
-                           series->setName(name + QString::number(nameIndex));
+                        nameIndex++;
-                           nameIndex++;
+                        chart->addSeries(series);
-                           chart->addSeries(series);
+                    chart->createDefaultAxes();
+                    QFont font;
-                       chart->createDefaultAxes();
+                    font.setPixelSize(m_fontSize);
-                       QFont font;
+                    chart->setTitleFont(font);
-                       font.setPixelSize(m_fontSize);
+                    chart->axisX()->setLabelsFont(font);
-                       chart->setTitleFont(font);
+                    chart->axisY()->setLabelsFont(font);
-                       chart->axisX()->setLabelsFont(font);
+                    return chart;
-                       chart->axisY()->setLabelsFont(font);
-                       return chart;
                 }
             private:
                 int m_fontSize;
             };
-            class FontChart6:public FontChart{
+            class FontChart6: public FontChart
+            {
             public:
-                FontChart6():FontChart(6){};
+                FontChart6(): FontChart(6) {};
             };
-            class FontChart8:public FontChart{
+            class FontChart8: public FontChart
+            {
             public:
-                FontChart8():FontChart(8){};
+                FontChart8(): FontChart(8) {};
             };
-            class FontChart10:public FontChart{
+            class FontChart10: public FontChart
+            {
             public:
-                FontChart10():FontChart(10){};
+                FontChart10(): FontChart(10) {};
             };
-            class FontChart14:public FontChart{
+            class FontChart14: public FontChart
+            {
             public:
-                FontChart14():FontChart(14){};
+                FontChart14(): FontChart(14) {};
             };
+            class FontChart18: public FontChart
-            class FontChart18:public FontChart{
             public:
-                FontChart18():FontChart(18){};
+                FontChart18(): FontChart(18) {};
             };
-            class FontChart20:public FontChart{
+            class FontChart20: public FontChart
+            {
             public:
-                FontChart20():FontChart(20){};
+                FontChart20(): FontChart(20) {};
             };
-            class FontChart24:public FontChart{
+            class FontChart24: public FontChart
+            {
             public:
-                FontChart24():FontChart(24){};
+                FontChart24(): FontChart(24) {};
             };
-            class FontChart28:public FontChart{
+            class FontChart28: public FontChart
+            {
             public:
-                FontChart28():FontChart(28){};
+                FontChart28(): FontChart(28) {};
             };
-            class FontChart32:public FontChart{
+            class FontChart32: public FontChart
+            {
             public:
-                FontChart32():FontChart(32){};
+                FontChart32(): FontChart(32) {};
             };
             DECLARE_CHART(FontChart6);

demos/chartviewer/charts/pieseries/donutchart.cpp +8 -10

                 QString category()  { return QObject::tr("PieSeries"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
+                 {
-                    QChart* chart = new QChart();
+                    QChart *chart = new QChart();
                     chart->setTitle("Donut chart");
+                    for (int i = 0, j = table.count(); i < table.count(); i++, j--) {
-                    for (int i = 0, j = table.count(); i < table.count(); i++,j--) {
                         QPieSeries *series = new QPieSeries(chart);
                         foreach (Data data, table[i]) {
                             QPieSlice *slice = series->append(data.second, data.first.y());
-                            if (data == table[i].first()) {
+                            if (data == table[i].first())
                                 slice->setLabelVisible();
                         }
-                        series->setPieSize( j / (qreal) table.count());
+                        series->setPieSize(j / (qreal) table.count());
-                        if(j>1) series->setHoleSize( (j-1)/ (qreal) table.count()+0.1);
+                        if (j > 1)
+                            series->setHoleSize((j - 1) / (qreal) table.count() + 0.1);
                         series->setHorizontalPosition(0.5);
                         series->setVerticalPosition(0.5);
                         chart->addSeries(series);
                     }
                     return chart;
                 }
             };
             DECLARE_CHART(DonutChart)

demos/chartviewer/charts/pieseries/piechart.cpp +2 -4

                 QString category()  { return QObject::tr("PieSeries"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
-                    QChart* chart = new QChart();
+                    QChart *chart = new QChart();
                     chart->setTitle("Pie chart");
                     qreal pieSize = 1.0 / table.count();
                     for (int i = 0; i < table.count(); i++) {
                         QPieSeries *series = new QPieSeries(chart);
                     }
                     return chart;
                 }
             };
             DECLARE_CHART(PieChart)

demos/chartviewer/charts/xyseries/areachart.cpp +3 -7

                 QString category()  { return QObject::tr("XYSeries"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = new QChart();
                     chart->setTitle("Area chart");
                             if (lowerSeries) {
                                 const QList<QPointF>& points = lowerSeries->points();
                                 upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
+                            } else {
-                            else
                                 upperSeries->append(QPointF(j, data.first.y()));
+                            }
                         }
                         QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                         area->setName(name + QString::number(nameIndex));
                         chart->createDefaultAxes();
                         lowerSeries = upperSeries;
                     }
                     return chart;
                 }
             };
             DECLARE_CHART(AreaChart)

demos/chartviewer/charts/xyseries/linechart.cpp +16 -20

@@ -29,27 +29,23 public:
29	QString category() { return QObject::tr("XYSeries"); }	29	QString category() { return QObject::tr("XYSeries"); }
30	QString subCategory() { return QString::null; }	30	QString subCategory() { return QString::null; }
31		31
32	QChart* createChart(const DataTable& table) {	32	QChart *createChart(const DataTable &table)
33		33	{
34	QChart* chart = new QChart();	34	QChart *chart = new QChart();
35	chart->setTitle("Line chart");	35	chart->setTitle("Line chart");
36		36	QString name("Series ");
37	QString name("Series ");	37	int nameIndex = 0;
38	int nameIndex = 0;	38	foreach (DataList list, table) {
39	foreach (DataList list, table) {	39	QLineSeries *series = new QLineSeries(chart);
40	QLineSeries *series = new QLineSeries(chart);	40	foreach (Data data, list)
41	~~foreach~~ (~~Data~~ data, list)	41	series->append(data.first);
42	series->append(data.first);	42	series->setName(name + QString::number(nameIndex));
43	series->setName(name + QString::number(nameIndex));	43	nameIndex++;
44	nameIndex++;	44	chart->addSeries(series);
45	chart->addSeries(series);	45	}
46	}	46	chart->createDefaultAxes();
47		47	return chart;
48	chart->createDefaultAxes();
49
50	return chart;
51	}	48	}
52
53	};	49	};
54		50
55	DECLARE_CHART(LineChart)	51	DECLARE_CHART(LineChart)

demos/chartviewer/charts/xyseries/scatterchart.cpp +2 -5

                 QString category()  { return QObject::tr("XYSeries"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Scatter chart");
                     QString name("Series ");
                     int nameIndex = 0;
                         chart->addSeries(series);
                     }
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(ScatterChart)

demos/chartviewer/charts/xyseries/splinechart.cpp +2 -5

                 QString category()  { return QObject::tr("XYSeries"); }
                 QString subCategory() { return QString::null; }
-                QChart* createChart(const DataTable& table)
+                QChart *createChart(const DataTable &table)
                 {
+                    QChart *chart = new QChart();
-                    QChart* chart = new QChart();
                     chart->setTitle("Spline chart");
                     QString name("Series ");
                     int nameIndex = 0;
                     chart->createDefaultAxes();
                     return chart;
                 }
             };
             DECLARE_CHART(SplineChart)

demos/chartviewer/model.h +3 -5

             class Model
             {
             private:
-                Model(){}
+                Model() {}
             public:
                 static DataTable generateRandomData(int listCount, int valueMax, int valueCount)
                         DataList dataList;
                         qreal yValue(0);
                         for (int j(0); j < valueCount; j++) {
-                            yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
+                            yValue = yValue + (qreal)(qrand() % valueMax) / (qreal) valueCount;
                             QPointF value(
                                 (j + (qreal) qrand() / (qreal) RAND_MAX)
-                                    * ((qreal) valueMax / (qreal) valueCount), yValue);
+                                * ((qreal) valueMax / (qreal) valueCount), yValue);
                             QString label = "Slice " + QString::number(i) + ":" + QString::number(j);
                             dataList << Data(value, label);
                         }
                         dataTable << dataList;
                     }
                     return dataTable;
                 }
             };
             #endif

demos/chartviewer/view.cpp +4 -4

             #include <QResizeEvent>
             #include <QDebug>
-            View::View(QGraphicsScene *scene, QGraphicsWidget *form , QWidget *parent):QGraphicsView(scene,parent),
+            View::View(QGraphicsScene *scene, QGraphicsWidget *form , QWidget *parent)
-                m_form(form)
+                : QGraphicsView(scene, parent),
+                  m_form(form)
             {
                 setDragMode(QGraphicsView::NoDrag);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
             void View::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsView::mouseReleaseEvent(event);
-               //BugFix somehow view always eats the mouse release event;
+                //BugFix somehow view always eats the mouse release event;
                 event->setAccepted(false);
             }

demos/chartviewer/window.cpp +92 -112

             #include <QDebug>
             #include <QMenu>
-            Window::Window(QWidget* parent) :
+            Window::Window(QWidget *parent) :
                 QMainWindow(parent),
                 m_listCount(3),
                 m_valueMax(10),
                 Charts::ChartList list = Charts::chartList();
                 for (int i = 0; i < 9; ++i) {
-                    QChart* chart = 0;
+                    QChart *chart = 0;
-                    if(i<list.size()){
+                    if (i < list.size()) {
-                    chart = list.at(i)->createChart(m_dataTable);
+                        chart = list.at(i)->createChart(m_dataTable);
-                    }else{
+                    } else {
-                    chart = new QChart();
+                        chart = new QChart();
-                    chart->setTitle(tr("Empty"));
+                        chart->setTitle(tr("Empty"));
                     }
                     m_baseLayout->addItem(chart, i / 3, i % 3);
             void Window::connectSignals()
             {
-                QObject::connect(m_form, SIGNAL(geometryChanged()),this ,SLOT(handleGeometryChanged()));
+                QObject::connect(m_form, SIGNAL(geometryChanged()), this , SLOT(handleGeometryChanged()));
                 QObject::connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 m_openGLCheckBox = new QCheckBox(tr("OpenGL"));
                 m_zoomCheckBox = new QCheckBox(tr("Zoom"));
                 m_scrollCheckBox = new QCheckBox(tr("Scroll"));
-                m_templateComboBox= createTempleteBox();
+                m_templateComboBox = createTempleteBox();
                 m_widgetHash["themeComboBox"] = m_scene->addWidget(m_themeComboBox);
                 m_widgetHash["antialiasCheckBox"] = m_scene->addWidget(m_antialiasCheckBox);
                 m_widgetHash["animatedComboBox"] = m_scene->addWidget(m_animatedComboBox);
             }
-            QComboBox* Window::createThemeBox()
+            QComboBox *Window::createThemeBox()
             {
-                QComboBox* themeComboBox = new ComboBox(this);
+                QComboBox *themeComboBox = new ComboBox(this);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 return themeComboBox;
             }
-            QComboBox* Window::createAnimationBox()
+            QComboBox *Window::createAnimationBox()
             {
-                QComboBox* animationComboBox = new ComboBox(this);
+                QComboBox *animationComboBox = new ComboBox(this);
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 return animationComboBox;
             }
-            QComboBox* Window::createLegendBox()
+            QComboBox *Window::createLegendBox()
             {
-                QComboBox* legendComboBox = new ComboBox(this);
+                QComboBox *legendComboBox = new ComboBox(this);
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 return legendComboBox;
             }
-            QComboBox* Window::createTempleteBox()
+            QComboBox *Window::createTempleteBox()
             {
-                QComboBox* templateComboBox = new ComboBox(this);
+                QComboBox *templateComboBox = new ComboBox(this);
                 templateComboBox->addItem("No Template", 0);
                 Charts::ChartList list = Charts::chartList();
-                QMultiMap<QString, Chart*> categoryMap;
+                QMultiMap<QString, Chart *> categoryMap;
-                foreach(Chart* chart, list) {
+                foreach (Chart *chart, list)
-                      categoryMap.insertMulti(chart->category(), chart);
+                    categoryMap.insertMulti(chart->category(), chart);
-                foreach(const QString& category, categoryMap.uniqueKeys()) {
+                foreach (const QString &category, categoryMap.uniqueKeys())
                     templateComboBox->addItem(category, category);
                 return templateComboBox;
             }
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
-                    foreach (QChart *chart, m_chartHash.keys()) {
+                    foreach (QChart *chart, m_chartHash.keys())
                         chart->legend()->hide();
+                } else {
-                else {
                     foreach (QChart *chart, m_chartHash.keys()) {
                         chart->legend()->setAlignment(alignment);
                         chart->legend()->show();
             void Window::checkOpenGL()
             {
                 bool opengl = m_openGLCheckBox->isChecked();
-                bool isOpengl = qobject_cast<QGLWidget*>(m_view->viewport());
+                bool isOpengl = qobject_cast<QGLWidget *>(m_view->viewport());
                 if ((isOpengl && !opengl) || (!isOpengl && opengl)) {
                     m_view->deleteLater();
                     m_view = new View(m_scene, m_form);
                 bool antialias = m_antialiasCheckBox->isChecked();
-                   if (opengl)
+                if (opengl)
-                       m_view->setRenderHint(QPainter::HighQualityAntialiasing, antialias);
+                    m_view->setRenderHint(QPainter::HighQualityAntialiasing, antialias);
-                   else
+                else
-                       m_view->setRenderHint(QPainter::Antialiasing, antialias);
+                    m_view->setRenderHint(QPainter::Antialiasing, antialias);
             }
             void Window::checkAnimationOptions()
             {
                 QChart::AnimationOptions options(
-                       m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
+                    m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
-                   if (!m_chartHash.isEmpty() && m_chartHash.keys().at(0)->animationOptions() != options) {
-                       foreach (QChart *chart, m_chartHash.keys())
+                if (!m_chartHash.isEmpty() && m_chartHash.keys().at(0)->animationOptions() != options) {
-                           chart->setAnimationOptions(options);
+                    foreach (QChart *chart, m_chartHash.keys())
+                        chart->setAnimationOptions(options);
+                }
             }
             void Window::checkState()
                 if (m_state != ScrollState && scroll) {
                     m_state = ScrollState;
                     m_zoomCheckBox->setChecked(false);
+                } else if (!scroll && m_state == ScrollState) {
-                else if (!scroll && m_state == ScrollState) {
                     m_state = NoState;
                 }
                 if (m_state != ZoomState && zoom) {
                     m_state = ZoomState;
                     m_scrollCheckBox->setChecked(false);
+                } else if (!zoom && m_state == ZoomState) {
-                else if (!zoom && m_state == ZoomState) {
                     m_state = NoState;
                 }
             }
                 QString category = m_templateComboBox->itemData(index).toString();
                 Charts::ChartList list = Charts::chartList();
-                QList<QChart*> qchartList = m_chartHash.keys();
+                QList<QChart *> qchartList = m_chartHash.keys();
-                foreach(QChart* qchart,qchartList){
+                foreach (QChart *qchart, qchartList) {
-                for(int i = 0 ; i < m_baseLayout->count();++i)
+                    for (int i = 0 ; i < m_baseLayout->count(); ++i) {
+                        if (m_baseLayout->itemAt(i) == qchart) {
-                           if(m_baseLayout->itemAt(i)==qchart){
+                            m_baseLayout->removeAt(i);
-                               m_baseLayout->removeAt(i);
+                            break;
-                               break;
+                    }
                 }
                 m_chartHash.clear();
                 qDeleteAll(qchartList);
-                QChart* qchart(0);
+                QChart *qchart(0);
-                int j=0;
+                int j = 0;
                 for (int i = 0; i < list.size(); ++i) {
-                    Chart* chart = list.at(i);
+                    Chart *chart = list.at(i);
                     if (chart->category() == category && j < 9) {
                         qchart = list.at(i)->createChart(m_dataTable);
                         m_baseLayout->addItem(qchart, j / 3, j % 3);
             void Window::checkTheme()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(
-                    m_themeComboBox->currentIndex()).toInt();
+                                               m_themeComboBox->currentIndex()).toInt();
                 foreach (QChart *chart, m_chartHash.keys())
                     chart->setTheme(theme);
                 if (theme == QChart::ChartThemeLight) {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                } else if (theme == QChart::ChartThemeDark) {
-                else if (theme == QChart::ChartThemeDark) {
                     pal.setColor(QPalette::Window, QRgb(0x121218));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
+                } else if (theme == QChart::ChartThemeBlueCerulean) {
-                else if (theme == QChart::ChartThemeBlueCerulean) {
                     pal.setColor(QPalette::Window, QRgb(0x40434a));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
+                } else if (theme == QChart::ChartThemeBrownSand) {
-                else if (theme == QChart::ChartThemeBrownSand) {
                     pal.setColor(QPalette::Window, QRgb(0x9e8965));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                } else if (theme == QChart::ChartThemeBlueNcs) {
-                else if (theme == QChart::ChartThemeBlueNcs) {
                     pal.setColor(QPalette::Window, QRgb(0x018bba));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                } else if (theme == QChart::ChartThemeHighContrast) {
-                else if (theme == QChart::ChartThemeHighContrast) {
                     pal.setColor(QPalette::Window, QRgb(0xffab03));
                     pal.setColor(QPalette::WindowText, QRgb(0x181818));
+                } else if (theme == QChart::ChartThemeBlueIcy) {
-                else if (theme == QChart::ChartThemeBlueIcy) {
                     pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
+                } else {
-                else {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 }
-                foreach(QGraphicsProxyWidget* widget , m_widgetHash) {
+                foreach (QGraphicsProxyWidget *widget, m_widgetHash)
                     widget->setPalette(pal);
                 m_view->setBackgroundBrush(pal.color((QPalette::Window)));
                 m_rubberBand->setPen(pal.color((QPalette::WindowText)));
             }
                         plotArea.translate(geometryRect.topLeft());
                         if (plotArea.contains(m_origin)) {
                             m_currentState = m_state;
+                            if (m_currentState == NoState && m_templateComboBox->currentIndex() == 0)
-                            if (m_currentState == NoState && m_templateComboBox->currentIndex()==0) {
                                 handleMenu(chart);
                             break;
                         }
                     }
             void Window::mouseMoveEvent(QMouseEvent *event)
             {
-                if ( m_currentState != NoState) {
+                if (m_currentState != NoState) {
                     foreach (QChart *chart, m_chartHash.keys()) {
                                 QPointF delta = m_origin - event->pos();
                                 chart->scroll(delta.x(), -delta.y());
                             }
-                            if (m_currentState == ZoomState && plotArea.contains(event->pos())) {
+                            if (m_currentState == ZoomState && plotArea.contains(event->pos()))
                                 m_rubberBand->setRect(QRectF(m_origin, event->pos()).normalized());
                             break;
                         }
                     }
-                    if(m_currentState == ScrollState) m_origin = event->pos();
+                    if (m_currentState == ScrollState)
+                        m_origin = event->pos();
                     event->accept();
                 }
             }
             void Window::comboBoxFocused(QComboBox *combobox)
             {
-                foreach(QGraphicsProxyWidget* widget , m_widgetHash) {
+                foreach (QGraphicsProxyWidget *widget , m_widgetHash) {
-                   if(widget->widget()==combobox)
+                    if (widget->widget() == combobox)
-                    widget->setZValue(2.0);
+                        widget->setZValue(2.0);
-                   else
+                    else
-                    widget->setZValue(0.0);
+                        widget->setZValue(0.0);
                 }
             }
-            void Window::handleMenu(QChart* qchart)
+            void Window::handleMenu(QChart *qchart)
             {
                 QAction *chosen = m_menu->exec(QCursor::pos());
                 if (chosen) {
-                    Chart* chart = (Chart *) chosen->data().value<void *>();
+                    Chart *chart = (Chart *) chosen->data().value<void *>();
                     int index = m_chartHash[qchart];
                     //not in 4.7.2 m_baseLayout->removeItem(qchart);
-                    for(int i = 0 ; i < m_baseLayout->count();++i)
+                    for (int i = 0 ; i < m_baseLayout->count(); ++i) {
+                        if (m_baseLayout->itemAt(i) == qchart) {
-                        if(m_baseLayout->itemAt(i)==qchart){
                             m_baseLayout->removeAt(i);
                             break;
                         }
                     }
                     m_chartHash.remove(qchart);
-                    QChart* newChart = chart->createChart(m_dataTable);
+                    QChart *newChart = chart->createChart(m_dataTable);
                     m_baseLayout->addItem(newChart, index / 3, index % 3);
                     m_chartHash[newChart] = index;
                     delete qchart;
             }
-            QMenu* Window::createMenu()
+            QMenu *Window::createMenu()
             {
                 Charts::ChartList list = Charts::chartList();
-                QMultiMap<QString, Chart*> categoryMap;
+                QMultiMap<QString, Chart *> categoryMap;
-                QMenu* result = new QMenu(this);
+                QMenu *result = new QMenu(this);
-                foreach(Chart* chart, list) {
+                foreach (Chart *chart, list)
                     categoryMap.insertMulti(chart->category(), chart);
-                foreach(const QString& category, categoryMap.uniqueKeys()) {
+                foreach (const QString &category, categoryMap.uniqueKeys()) {
-                    QMenu* menu(0);
+                    QMenu *menu(0);
-                    QMultiMap<QString, Chart*> subCategoryMap;
+                    QMultiMap<QString, Chart *> subCategoryMap;
                     if (category.isEmpty()) {
                         menu = result;
+                    } else {
-                    else {
                         menu = new QMenu(category, this);
                         result->addMenu(menu);
                     }
-                    foreach(Chart* chart , categoryMap.values(category)) {
+                    foreach (Chart *chart, categoryMap.values(category))
                         subCategoryMap.insert(chart->subCategory(), chart);
-                    foreach(const QString& subCategory, subCategoryMap.uniqueKeys()) {
+                    foreach (const QString &subCategory, subCategoryMap.uniqueKeys()) {
-                        QMenu* subMenu(0);
+                        QMenu *subMenu(0);
                         if (subCategory.isEmpty()) {
                             subMenu = menu;
+                        } else {
-                        else {
                             subMenu = new QMenu(subCategory, this);
                             menu->addMenu(subMenu);
                         }
-                        foreach(Chart* chart , subCategoryMap.values(subCategory)) {
+                        foreach(Chart *chart, subCategoryMap.values(subCategory)) {
                             createMenuAction(subMenu, QIcon(), chart->name(),
-                                qVariantFromValue((void *) chart));
+                                             qVariantFromValue((void *) chart));
                         }
                     }
                 }
                 return result;
             }
-            QAction* Window::createMenuAction(QMenu *menu, const QIcon &icon, const QString &text,
+            QAction *Window::createMenuAction(QMenu *menu, const QIcon &icon, const QString &text,
-                const QVariant &data)
+                                              const QVariant &data)
             {
                 QAction *action = menu->addAction(icon, text);
                 action->setCheckable(false);
             void Window::handleGeometryChanged()
             {
-               QSizeF size = m_baseLayout->sizeHint(Qt::MinimumSize);
+                QSizeF size = m_baseLayout->sizeHint(Qt::MinimumSize);
-               m_view->scene()->setSceneRect(0, 0, this->width(), this->height());
+                m_view->scene()->setSceneRect(0, 0, this->width(), this->height());
-               m_view->setMinimumSize(size.toSize());
+                m_view->setMinimumSize(size.toSize());
             }

demos/chartviewer/window.h +18 -19

             class Window: public QMainWindow
             {
                 Q_OBJECT
-                enum State{ NoState = 0, ZoomState, ScrollState};
+                enum State { NoState = 0, ZoomState, ScrollState};
             public:
                 explicit Window(QWidget *parent = 0);
                 ~Window();
                 void updateUI();
                 void handleGeometryChanged();
             private:
-                QComboBox* createThemeBox();
+                QComboBox *createThemeBox();
-                QComboBox* createAnimationBox();
+                QComboBox *createAnimationBox();
-                QComboBox* createLegendBox();
+                QComboBox *createLegendBox();
-                QComboBox* createTempleteBox();
+                QComboBox *createTempleteBox();
                 void connectSignals();
                 void createProxyWidgets();
                 void comboBoxFocused(QComboBox *combox);
                 inline void checkTheme();
                 inline void checkState();
                 inline void checkTemplate();
-                QMenu* createMenu();
+                QMenu *createMenu();
-                void handleMenu(QChart * chart);
+                void handleMenu(QChart *chart);
-                QAction* createMenuAction(QMenu *menu, const QIcon &icon, const QString &text, const QVariant &data);
+                QAction *createMenuAction(QMenu *menu, const QIcon &icon, const QString &text, const QVariant &data);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 int m_listCount;
                 int m_valueMax;
                 int m_valueCount;
-                QGraphicsScene* m_scene;
+                QGraphicsScene *m_scene;
-                View* m_view;
+                View *m_view;
-                QHash<QString, QGraphicsProxyWidget*> m_widgetHash;
+                QHash<QString, QGraphicsProxyWidget *> m_widgetHash;
-                QHash<QChart*, int> m_chartHash;
+                QHash<QChart *, int> m_chartHash;
                 DataTable m_dataTable;
                 QGraphicsWidget *m_form;
                 QCheckBox *m_zoomCheckBox;
                 QCheckBox *m_scrollCheckBox;
                 QPoint m_origin;
-                QGraphicsRectItem* m_rubberBand;
+                QGraphicsRectItem *m_rubberBand;
-                QGraphicsGridLayout* m_baseLayout;
+                QGraphicsGridLayout *m_baseLayout;
-                QMenu* m_menu;
+                QMenu *m_menu;
                 State m_state;
                 State m_currentState;
                 int m_template;
             class ComboBox: public QComboBox
             {
             public:
-                ComboBox(Window* window,QWidget *parent = 0):QComboBox(parent),m_window(window)
+                ComboBox(Window *window, QWidget *parent = 0): QComboBox(parent), m_window(window)
                 {}
             protected:
-                void focusInEvent(QFocusEvent *e)
+                void focusInEvent(QFocusEvent *e) {
                     QComboBox::focusInEvent(e);
                     m_window->comboBoxFocused(this);
                 }
             private:
-                Window* m_window;
+                Window *m_window;
             };
             #endif

demos/dynamicspline/chart.cpp +6 -5

                 addSeries(m_series);
                 createDefaultAxes();
-                setAxisX(m_axis,m_series);
+                setAxisX(m_axis, m_series);
                 m_axis->setTickCount(5);
                 axisX()->setRange(0, 10);
                 axisY()->setRange(-5, 10);
             void Chart::handleTimeout()
             {
-                qreal x = plotArea().width()/m_axis->tickCount();
+                qreal x = plotArea().width() / m_axis->tickCount();
-                qreal y =(m_axis->max() - m_axis->min())/m_axis->tickCount();
+                qreal y = (m_axis->max() - m_axis->min()) / m_axis->tickCount();
                 m_x += y;
                 m_y = qrand() % 5 - 2.5;
                 m_series->append(m_x, m_y);
-                scroll(x,0);
+                scroll(x, 0);
-                if(m_x==100) m_timer.stop();
+                if (m_x == 100)
+                    m_timer.stop();
             }

demos/dynamicspline/chart.h +2 -2

             private:
                 QTimer m_timer;
-                QSplineSeries* m_series;
+                QSplineSeries *m_series;
                 QStringList m_titles;
-                QValueAxis* m_axis;
+                QValueAxis *m_axis;
                 qreal m_step;
                 qreal m_x;
                 qreal m_y;

demos/nesteddonuts/main.cpp 0 -1

                 QApplication a(argc, argv);
                 Widget w;
                 w.show();
                 return a.exec();
             }

demos/nesteddonuts/widget.cpp +9 -9

             Widget::Widget(QWidget *parent)
                 : QWidget(parent)
+            {
                 setMinimumSize(800, 600);
-                qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
+                qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 //! [1]
                 QChartView *chartView = new QChartView;
                 chartView->setRenderHint(QPainter::Antialiasing);
                 QChart *chart = chartView->chart();
                 chart->legend()->setVisible(false);
                 chart->setTitle("Nested donuts demo");
                 chart->setAnimationOptions(QChart::AllAnimations);
                 // create main layout
                 //! [4]
-                QGridLayout* mainLayout = new QGridLayout;
+                QGridLayout *mainLayout = new QGridLayout;
                 mainLayout->addWidget(chartView, 1, 1);
                 setLayout(mainLayout);
                 //! [4]
             Widget::~Widget()
             {
             }
-                //! [6]
+            //! [6]
             void Widget::updateRotation()
             {
                 for (int i = 0; i < m_donuts.count(); i++) {
                     donut->setPieEndAngle(donut->pieEndAngle() + phaseShift);
                 }
             }
-                //! [6]
+            //! [6]
-                //! [7]
+            //! [7]
             void Widget::explodeSlice(bool exploded)
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 }
                 slice->setExploded(exploded);
             }
-                //! [7]
+            //! [7]

demos/nesteddonuts/widget.h +1 -1

             class Widget : public QWidget
             {
                 Q_OBJECT
             public:
                 Widget(QWidget *parent = 0);
                 ~Widget();

demos/piechartcustomization/brushtool.cpp +1 -1

             #include <QColorDialog>
             BrushTool::BrushTool(QString title, QWidget *parent)
-                :QWidget(parent)
+                : QWidget(parent)
             {
                 setWindowTitle(title);
                 setWindowFlags(Qt::Tool);

demos/piechartcustomization/customslice.cpp +1 -1

             QTCOMMERCIALCHART_USE_NAMESPACE
             CustomSlice::CustomSlice(QString label, qreal value)
-                :QPieSlice(label, value)
+                : QPieSlice(label, value)
             {
                 connect(this, SIGNAL(hovered(bool)), this, SLOT(showHighlight(bool)));
             }

demos/piechartcustomization/mainwidget.cpp +17 -17

             QTCOMMERCIALCHART_USE_NAMESPACE
-            MainWidget::MainWidget(QWidget* parent)
+            MainWidget::MainWidget(QWidget *parent)
-                :QWidget(parent),
+                : QWidget(parent),
                   m_slice(0)
             {
                 // create chart
                 m_legendCheckBox = new QCheckBox();
-                QFormLayout* chartSettingsLayout = new QFormLayout();
+                QFormLayout *chartSettingsLayout = new QFormLayout();
                 chartSettingsLayout->addRow("Theme", m_themeComboBox);
                 chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                 chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                 chartSettingsLayout->addRow("Legend", m_legendCheckBox);
-                QGroupBox* chartSettings = new QGroupBox("Chart");
+                QGroupBox *chartSettings = new QGroupBox("Chart");
                 chartSettings->setLayout(chartSettingsLayout);
-                connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateChartSettings()));
+                connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateChartSettings()));
-                connect(m_aaCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
+                connect(m_aaCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateChartSettings()));
-                connect(m_animationsCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
+                connect(m_animationsCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateChartSettings()));
-                connect(m_legendCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
+                connect(m_legendCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateChartSettings()));
                 // series settings
                 m_hPosition = new QDoubleSpinBox();
                 QPushButton *insertSlice = new QPushButton("Insert slice");
                 QPushButton *removeSlice = new QPushButton("Remove selected slice");
-                QFormLayout* seriesSettingsLayout = new QFormLayout();
+                QFormLayout *seriesSettingsLayout = new QFormLayout();
                 seriesSettingsLayout->addRow("Horizontal position", m_hPosition);
                 seriesSettingsLayout->addRow("Vertical position", m_vPosition);
                 seriesSettingsLayout->addRow("Size factor", m_sizeFactor);
                 seriesSettingsLayout->addRow(appendSlice);
                 seriesSettingsLayout->addRow(insertSlice);
                 seriesSettingsLayout->addRow(removeSlice);
-                QGroupBox* seriesSettings = new QGroupBox("Series");
+                QGroupBox *seriesSettings = new QGroupBox("Series");
                 seriesSettings->setLayout(seriesSettingsLayout);
                 connect(m_vPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 m_labelPosition->addItem("Inside tangential", QPieSlice::LabelInsideTangential);
                 m_labelPosition->addItem("Inside normal", QPieSlice::LabelInsideNormal);
-                QFormLayout* sliceSettingsLayout = new QFormLayout();
+                QFormLayout *sliceSettingsLayout = new QFormLayout();
                 sliceSettingsLayout->addRow("Label", m_sliceName);
                 sliceSettingsLayout->addRow("Value", m_sliceValue);
                 sliceSettingsLayout->addRow("Pen", m_pen);
                 sliceSettingsLayout->addRow("Label arm length", m_sliceLabelArmFactor);
                 sliceSettingsLayout->addRow("Exploded", m_sliceExploded);
                 sliceSettingsLayout->addRow("Explode distance", m_sliceExplodedFactor);
-                QGroupBox* sliceSettings = new QGroupBox("Selected slice");
+                QGroupBox *sliceSettings = new QGroupBox("Selected slice");
                 sliceSettings->setLayout(sliceSettingsLayout);
                 connect(m_sliceName, SIGNAL(textChanged(QString)), this, SLOT(updateSliceSettings()));
                 settingsLayout->addWidget(sliceSettings);
                 settingsLayout->addStretch();
-                QGridLayout* baseLayout = new QGridLayout();
+                QGridLayout *baseLayout = new QGridLayout();
                 baseLayout->addLayout(settingsLayout, 0, 0);
                 baseLayout->addWidget(m_chartView, 0, 1);
                 setLayout(baseLayout);
                 m_slice->setExplodeDistanceFactor(m_sliceExplodedFactor->value());
             }
-            void MainWidget::handleSliceClicked(QPieSlice* slice)
+            void MainWidget::handleSliceClicked(QPieSlice *slice)
             {
-                m_slice = static_cast<CustomSlice*>(slice);
+                m_slice = static_cast<CustomSlice *>(slice);
                 // name
                 m_sliceName->blockSignals(true);
             void MainWidget::appendSlice()
             {
-                *m_series << new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0);
+                *m_series << new CustomSlice("Slice " + QString::number(m_series->count() + 1), 10.0);
             }
             void MainWidget::insertSlice()
                 int i = m_series->slices().indexOf(m_slice);
-                m_series->insert(i, new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0));
+                m_series->insert(i, new CustomSlice("Slice " + QString::number(m_series->count() + 1), 10.0));
             }
             void MainWidget::removeSlice()

demos/piechartcustomization/mainwidget.h +17 -17

                 Q_OBJECT
             public:
-                explicit MainWidget(QWidget* parent = 0);
+                explicit MainWidget(QWidget *parent = 0);
             public Q_SLOTS:
                 void updateChartSettings();
                 void updateSerieSettings();
                 void updateSliceSettings();
-                void handleSliceClicked(QPieSlice* slice);
+                void handleSliceClicked(QPieSlice *slice);
                 void showFontDialog();
                 void appendSlice();
                 void insertSlice();
                 QCheckBox *m_animationsCheckBox;
                 QCheckBox *m_legendCheckBox;
-                QChartView* m_chartView;
+                QChartView *m_chartView;
-                QPieSeries* m_series;
+                QPieSeries *m_series;
-                CustomSlice* m_slice;
+                CustomSlice *m_slice;
-                QDoubleSpinBox* m_hPosition;
+                QDoubleSpinBox *m_hPosition;
-                QDoubleSpinBox* m_vPosition;
+                QDoubleSpinBox *m_vPosition;
-                QDoubleSpinBox* m_sizeFactor;
+                QDoubleSpinBox *m_sizeFactor;
-                QDoubleSpinBox* m_startAngle;
+                QDoubleSpinBox *m_startAngle;
-                QDoubleSpinBox* m_endAngle;
+                QDoubleSpinBox *m_endAngle;
-                QDoubleSpinBox* m_holeSize;
+                QDoubleSpinBox *m_holeSize;
-                QLineEdit* m_sliceName;
+                QLineEdit *m_sliceName;
-                QDoubleSpinBox* m_sliceValue;
+                QDoubleSpinBox *m_sliceValue;
-                QCheckBox* m_sliceLabelVisible;
+                QCheckBox *m_sliceLabelVisible;
-                QDoubleSpinBox* m_sliceLabelArmFactor;
+                QDoubleSpinBox *m_sliceLabelArmFactor;
-                QCheckBox* m_sliceExploded;
+                QCheckBox *m_sliceExploded;
-                QDoubleSpinBox* m_sliceExplodedFactor;
+                QDoubleSpinBox *m_sliceExplodedFactor;
                 QPushButton *m_brush;
                 BrushTool *m_brushTool;
                 QPushButton *m_pen;

demos/piechartcustomization/pentool.cpp +1 -1

             #include <QColorDialog>
             PenTool::PenTool(QString title, QWidget *parent)
-                :QWidget(parent)
+                : QWidget(parent)
             {
                 setWindowTitle(title);
                 setWindowFlags(Qt::Tool);

demos/qmlcustomlegend/main.cpp 755 ➡ 644 +38 -38

@@ -1,40 +1,40
1	/****************************************************************************	1	/****************************************************************************
2	**	2	**
3	** Copyright (C) 2012 Digia Plc	3	** Copyright (C) 2012 Digia Plc
4	** All rights reserved.	4	** All rights reserved.
5	** For any questions to Digia, please use contact form at http://qt.digia.com	5	** For any questions to Digia, please use contact form at http://qt.digia.com
6	**	6	**
7	** This file is part of the Qt Commercial Charts Add-on.	7	** This file is part of the Qt Commercial Charts Add-on.
8	**	8	**
9	** $QT_BEGIN_LICENSE$	9	** $QT_BEGIN_LICENSE$
10	** Licensees holding valid Qt Commercial licenses may use this file in	10	** Licensees holding valid Qt Commercial licenses may use this file in
11	** accordance with the Qt Commercial License Agreement provided with the	11	** accordance with the Qt Commercial License Agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in	12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and Digia.	13	** a written agreement between you and Digia.
14	**	14	**
15	** If you have questions regarding the use of this file, please use	15	** If you have questions regarding the use of this file, please use
16	** contact form at http://qt.digia.com	16	** contact form at http://qt.digia.com
17	** $QT_END_LICENSE$	17	** $QT_END_LICENSE$
18	**	18	**
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#include <QApplication>	21	#include <QApplication>
22	#ifdef QT5_QUICK_1	22	#ifdef QT5_QUICK_1
23	#include <QtQuick1/QDeclarativeEngine>	23	#include <QtQuick1/QDeclarativeEngine>
24	#else	24	#else
25	#include <QtDeclarative/QDeclarativeEngine>	25	#include <QtDeclarative/QDeclarativeEngine>
26	#endif	26	#endif
27	#include "qmlapplicationviewer.h"	27	#include "qmlapplicationviewer.h"
28		28
29	Q_DECL_EXPORT int main(int argc, char *argv[])	29	Q_DECL_EXPORT int main(int argc, char *argv[])
30	{	30	{
31	QScopedPointer<QApplication> app(createApplication(argc, argv));	31	QScopedPointer<QApplication> app(createApplication(argc, argv));
32	QScopedPointer<QmlApplicationViewer> viewer(QmlApplicationViewer::create());	32	QScopedPointer<QmlApplicationViewer> viewer(QmlApplicationViewer::create());
33		33
34	//viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);	34	//viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
35	viewer->setSource(QUrl("qrc:/qml/qmlcustomlegend/loader.qml"));	35	viewer->setSource(QUrl("qrc:/qml/qmlcustomlegend/loader.qml"));
36	viewer->setRenderHint(QPainter::Antialiasing, true);	36	viewer->setRenderHint(QPainter::Antialiasing, true);
37	viewer->showExpanded();	37	viewer->showExpanded();
38		38
39	return app->exec();	39	return app->exec();
40	}	40	}

demos/qmlcustomlegend/qmlapplicationviewer/qmlapplicationviewer.cpp 755 ➡ 644 0 0

NO CONTENT: modified file chmod 100755 => 100644

demos/qmlcustomlegend/qmlapplicationviewer/qmlapplicationviewer.h 755 ➡ 644 0 0

NO CONTENT: modified file chmod 100755 => 100644

demos/qmlcustommodel/customtablemodel.cpp +3 -3

             {
             }
-            int CustomTableModel::rowCount(const QModelIndex & parent) const
+            int CustomTableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent)
                 return m_data.count();
             }
-            int CustomTableModel::columnCount(const QModelIndex & parent) const
+            int CustomTableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent)
                 return m_columnCount;
                 return removed;
             }
-            Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
+            Qt::ItemFlags CustomTableModel::flags(const QModelIndex &index) const
             {
                 return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
             }

demos/qmlcustommodel/customtablemodel.h +7 -7

             public:
                 explicit CustomTableModel(QObject *parent = 0);
-                int rowCount ( const QModelIndex & parent = QModelIndex() ) const;
+                int rowCount(const QModelIndex &parent = QModelIndex()) const;
-                int columnCount ( const QModelIndex & parent = QModelIndex() ) const;
+                int columnCount(const QModelIndex &parent = QModelIndex()) const;
-                QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
+                QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
                 bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole);
                 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
-                bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
+                bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
-                Qt::ItemFlags flags ( const QModelIndex & index ) const;
+                Qt::ItemFlags flags(const QModelIndex &index) const;
                 void insertColumn(int column, const QModelIndex &parent = QModelIndex());
                 void insertRow(int row, const QModelIndex &parent = QModelIndex());
-                Q_INVOKABLE bool removeRows(int row, int count, const QModelIndex & parent = QModelIndex());
+                Q_INVOKABLE bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
-                Q_INVOKABLE bool removeRow (int row, const QModelIndex &parent = QModelIndex());
+                Q_INVOKABLE bool removeRow(int row, const QModelIndex &parent = QModelIndex());
                 Q_INVOKABLE QVariant at(int row, int column);
             private:

demos/qmloscilloscope/datasource.h +2 -2

                 Q_OBJECT
             public:
                 explicit DataSource(QDeclarativeView *appViewer, QObject *parent = 0);
             signals:
             public slots:
                 void generateData(int type, int rowCount, int colCount);
                 void update(QAbstractSeries *series);

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