##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » qtcharts
RSS

Clone from http://code.qt.io/qt/qtcharts.git

QBarCategoriesAxis renamed to QBarCategoryAxis
Marek Rosa -
r1808:f1a8cd777029
parent child
Show More
Side by Side Unified
Context file:
r1808:f1a8cd777029 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,92 +1,92
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28
29 29 QTCOMMERCIALCHART_USE_NAMESPACE
30 30
31 31 int main(int argc, char *argv[])
32 32 {
33 33 QApplication a(argc, argv);
34 34
35 35 //![1]
36 36 QBarSet *set0 = new QBarSet("Jane");
37 37 QBarSet *set1 = new QBarSet("John");
38 38 QBarSet *set2 = new QBarSet("Axel");
39 39 QBarSet *set3 = new QBarSet("Mary");
40 40 QBarSet *set4 = new QBarSet("Samantha");
41 41
42 42 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
43 43 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
44 44 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
45 45 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
46 46 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
47 47 //![1]
48 48
49 49 //![2]
50 50 QBarSeries* series = new QBarSeries();
51 51 series->append(set0);
52 52 series->append(set1);
53 53 series->append(set2);
54 54 series->append(set3);
55 55 series->append(set4);
56 56
57 57 //![2]
58 58
59 59 //![3]
60 60 QChart* chart = new QChart();
61 61 chart->addSeries(series);
62 62 chart->setTitle("Simple barchart example");
63 63 chart->createDefaultAxes();
64 64 //![3]
65 65
66 66 //![4]
67 67 QStringList categories;
68 68 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
69 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
69 QBarCategoryAxis* axis = new QBarCategoryAxis();
70 70 axis->append(categories);
71 71 chart->setAxisX(axis,series);
72 72 //![4]
73 73
74 74 //![5]
75 75 chart->legend()->setVisible(true);
76 76 chart->legend()->setAlignment(Qt::AlignBottom);
77 77 //![5]
78 78
79 79 //![6]
80 80 QChartView* chartView = new QChartView(chart);
81 81 chartView->setRenderHint(QPainter::Antialiasing);
82 82 //![6]
83 83
84 84 //![7]
85 85 QMainWindow window;
86 86 window.setCentralWidget(chartView);
87 87 window.resize(400, 300);
88 88 window.show();
89 89 //![7]
90 90
91 91 return a.exec();
92 92 }
Show file before | Show file after | Hide comments
@@ -1,112 +1,112
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "tablewidget.h"
22 22 #include "customtablemodel.h"
23 23 #include <QGridLayout>
24 24 #include <QTableView>
25 25 #include <QChart>
26 26 #include <QChartView>
27 27 #include <QLineSeries>
28 28 #include <QVXYModelMapper>
29 29 #include <QBarSeries>
30 30 #include <QBarSet>
31 31 #include <QVBarModelMapper>
32 32 #include <QHeaderView>
33 33 #include <QBarCategoriesAxis>
34 34
35 35 QTCOMMERCIALCHART_USE_NAMESPACE
36 36
37 37 TableWidget::TableWidget(QWidget *parent)
38 38 : QWidget(parent)
39 39 {
40 40 // create simple model for storing data
41 41 // user's table data model
42 42 //! [1]
43 43 CustomTableModel *model = new CustomTableModel;
44 44 //! [1]
45 45
46 46 //! [2]
47 47 // create table view and add model to it
48 48 QTableView *tableView = new QTableView;
49 49 tableView->setModel(model);
50 50 tableView->setMinimumWidth(300);
51 51 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
52 52 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
53 53 //! [2]
54 54
55 55 //! [3]
56 56 QChart *chart = new QChart;
57 57 chart->setAnimationOptions(QChart::AllAnimations);
58 58 //! [3]
59 59
60 60 // series 1
61 61 //! [4]
62 62 QBarSeries *series = new QBarSeries;
63 63
64 64 int first = 3;
65 65 int count = 5;
66 66 QVBarModelMapper *mapper = new QVBarModelMapper(this);
67 67 mapper->setFirstBarSetColumn(1);
68 68 mapper->setLastBarSetColumn(4);
69 69 mapper->setFirstRow(first);
70 70 mapper->setRowCount(count);
71 71 mapper->setSeries(series);
72 72 mapper->setModel(model);
73 73 chart->addSeries(series);
74 74 //! [4]
75 75
76 76 //! [5]
77 77 // for storing color hex from the series
78 78 QString seriesColorHex = "#000000";
79 79
80 80 // get the color of the series and use it for showing the mapped area
81 81 QList<QBarSet*> barsets = series->barSets();
82 82 for (int i = 0; i < barsets.count(); i++) {
83 83 seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
84 84 model->addMapping(seriesColorHex, QRect(1 + i, first, 1, barsets.at(i)->count()));
85 85 }
86 86 //! [5]
87 87
88 88 //! [6]
89 89 QStringList categories;
90 90 categories << "April" << "May" << "June" << "July" << "August";
91 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
91 QBarCategoryAxis* axis = new QBarCategoryAxis();
92 92 axis->append(categories);
93 93 chart->createDefaultAxes();
94 94 chart->setAxisX(axis, series);
95 95 //! [6]
96 96
97 97 //! [7]
98 98 QChartView *chartView = new QChartView(chart);
99 99 chartView->setRenderHint(QPainter::Antialiasing);
100 100 chartView->setMinimumSize(640, 480);
101 101 //! [7]
102 102
103 103 //! [8]
104 104 // create main layout
105 105 QGridLayout* mainLayout = new QGridLayout;
106 106 mainLayout->addWidget(tableView, 1, 0);
107 107 mainLayout->addWidget(chartView, 1, 1);
108 108 mainLayout->setColumnStretch(1, 1);
109 109 mainLayout->setColumnStretch(0, 0);
110 110 setLayout(mainLayout);
111 111 //! [8]
112 112 }
Show file before | Show file after | Hide comments
@@ -1,94 +1,94
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28 #include <QHorizontalBarSeries>
29 29
30 30 QTCOMMERCIALCHART_USE_NAMESPACE
31 31
32 32 int main(int argc, char *argv[])
33 33 {
34 34 QApplication a(argc, argv);
35 35
36 36 //![1]
37 37 QBarSet *set0 = new QBarSet("Jane");
38 38 QBarSet *set1 = new QBarSet("John");
39 39 QBarSet *set2 = new QBarSet("Axel");
40 40 QBarSet *set3 = new QBarSet("Mary");
41 41 QBarSet *set4 = new QBarSet("Samantha");
42 42
43 43 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
44 44 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
45 45 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
46 46 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
47 47 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
48 48 //![1]
49 49
50 50 //![2]
51 51 QHorizontalBarSeries *series = new QHorizontalBarSeries();
52 52 series->append(set0);
53 53 series->append(set1);
54 54 series->append(set2);
55 55 series->append(set3);
56 56 series->append(set4);
57 57
58 58 //![2]
59 59
60 60 //![3]
61 61 QChart* chart = new QChart();
62 62 chart->addSeries(series);
63 63 chart->setTitle("Simple horizontal barchart example");
64 64 chart->createDefaultAxes();
65 65 chart->setAnimationOptions(QChart::SeriesAnimations);
66 66 //![3]
67 67
68 68 //![4]
69 69 QStringList categories;
70 70 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
71 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
71 QBarCategoryAxis* axis = new QBarCategoryAxis();
72 72 axis->append(categories);
73 73 chart->setAxisY(axis,series);
74 74 //![4]
75 75
76 76 //![5]
77 77 chart->legend()->setVisible(true);
78 78 chart->legend()->setAlignment(Qt::AlignBottom);
79 79 //![5]
80 80
81 81 //![6]
82 82 QChartView* chartView = new QChartView(chart);
83 83 chartView->setRenderHint(QPainter::Antialiasing);
84 84 //![6]
85 85
86 86 //![7]
87 87 QMainWindow window;
88 88 window.setCentralWidget(chartView);
89 89 window.resize(400, 300);
90 90 window.show();
91 91 //![7]
92 92
93 93 return a.exec();
94 94 }
Show file before | Show file after | Hide comments
@@ -1,95 +1,95
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28 #include <QHorizontalPercentBarSeries>
29 29
30 30 QTCOMMERCIALCHART_USE_NAMESPACE
31 31
32 32 int main(int argc, char *argv[])
33 33 {
34 34 QApplication a(argc, argv);
35 35
36 36 //![1]
37 37 QBarSet *set0 = new QBarSet("Jane");
38 38 QBarSet *set1 = new QBarSet("John");
39 39 QBarSet *set2 = new QBarSet("Axel");
40 40 QBarSet *set3 = new QBarSet("Mary");
41 41 QBarSet *set4 = new QBarSet("Samantha");
42 42
43 43 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
44 44 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
45 45 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
46 46 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
47 47 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
48 48 //![1]
49 49
50 50 //![2]
51 51 QHorizontalPercentBarSeries *series = new QHorizontalPercentBarSeries();
52 52 series->append(set0);
53 53 series->append(set1);
54 54 series->append(set2);
55 55 series->append(set3);
56 56 series->append(set4);
57 57
58 58 //![2]
59 59
60 60 //![3]
61 61 QChart* chart = new QChart();
62 62 chart->addSeries(series);
63 63 chart->setTitle("Simple horizontal percent barchart example");
64 64 chart->createDefaultAxes();
65 65 chart->setAnimationOptions(QChart::SeriesAnimations);
66 66 //![3]
67 67
68 68 //![4]
69 69 QStringList categories;
70 70 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
71 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
71 QBarCategoryAxis* axis = new QBarCategoryAxis();
72 72 axis->append(categories);
73 73 chart->createDefaultAxes();
74 74 chart->setAxisY(axis,series);
75 75 //![4]
76 76
77 77 //![5]
78 78 chart->legend()->setVisible(true);
79 79 chart->legend()->setAlignment(Qt::AlignBottom);
80 80 //![5]
81 81
82 82 //![6]
83 83 QChartView* chartView = new QChartView(chart);
84 84 chartView->setRenderHint(QPainter::Antialiasing);
85 85 //![6]
86 86
87 87 //![7]
88 88 QMainWindow window;
89 89 window.setCentralWidget(chartView);
90 90 window.resize(400, 300);
91 91 window.show();
92 92 //![7]
93 93
94 94 return a.exec();
95 95 }
Show file before | Show file after | Hide comments
@@ -1,95 +1,95
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28 #include <QHorizontalStackedBarSeries>
29 29
30 30 QTCOMMERCIALCHART_USE_NAMESPACE
31 31
32 32 int main(int argc, char *argv[])
33 33 {
34 34 QApplication a(argc, argv);
35 35
36 36 //![1]
37 37 QBarSet *set0 = new QBarSet("Jane");
38 38 QBarSet *set1 = new QBarSet("John");
39 39 QBarSet *set2 = new QBarSet("Axel");
40 40 QBarSet *set3 = new QBarSet("Mary");
41 41 QBarSet *set4 = new QBarSet("Samantha");
42 42
43 43 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
44 44 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
45 45 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
46 46 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
47 47 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
48 48 //![1]
49 49
50 50 //![2]
51 51 QHorizontalStackedBarSeries *series = new QHorizontalStackedBarSeries();
52 52 series->append(set0);
53 53 series->append(set1);
54 54 series->append(set2);
55 55 series->append(set3);
56 56 series->append(set4);
57 57
58 58 //![2]
59 59
60 60 //![3]
61 61 QChart* chart = new QChart();
62 62 chart->addSeries(series);
63 63 chart->setTitle("Simple horizontal stacked barchart example");
64 64 chart->createDefaultAxes();
65 65 chart->setAnimationOptions(QChart::SeriesAnimations);
66 66 //![3]
67 67
68 68 //![4]
69 69 QStringList categories;
70 70 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
71 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
71 QBarCategoryAxis* axis = new QBarCategoryAxis();
72 72 axis->append(categories);
73 73 chart->createDefaultAxes();
74 74 chart->setAxisY(axis,series);
75 75 //![4]
76 76
77 77 //![5]
78 78 chart->legend()->setVisible(true);
79 79 chart->legend()->setAlignment(Qt::AlignBottom);
80 80 //![5]
81 81
82 82 //![6]
83 83 QChartView* chartView = new QChartView(chart);
84 84 chartView->setRenderHint(QPainter::Antialiasing);
85 85 //![6]
86 86
87 87 //![7]
88 88 QMainWindow window;
89 89 window.setCentralWidget(chartView);
90 90 window.resize(400, 300);
91 91 window.show();
92 92 //![7]
93 93
94 94 return a.exec();
95 95 }
Show file before | Show file after | Hide comments
@@ -1,111 +1,111
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLineSeries>
27 27 #include <QLegend>
28 28 #include <QBarCategoriesAxis>
29 29 #include <QValueAxis>
30 30
31 31 QTCOMMERCIALCHART_USE_NAMESPACE
32 32
33 33 int main(int argc, char *argv[])
34 34 {
35 35 QApplication a(argc, argv);
36 36
37 37 //![1]
38 38 QBarSet *set0 = new QBarSet("Jane");
39 39 QBarSet *set1 = new QBarSet("John");
40 40 QBarSet *set2 = new QBarSet("Axel");
41 41 QBarSet *set3 = new QBarSet("Mary");
42 42 QBarSet *set4 = new QBarSet("Samantha");
43 43
44 44 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
45 45 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
46 46 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
47 47 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
48 48 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
49 49 //![1]
50 50
51 51 //![2]
52 52 QBarSeries* barseries = new QBarSeries();
53 53 barseries->append(set0);
54 54 barseries->append(set1);
55 55 barseries->append(set2);
56 56 barseries->append(set3);
57 57 barseries->append(set4);
58 58 //![2]
59 59
60 60 //![8]
61 61 QLineSeries* lineseries = new QLineSeries();
62 62
63 63 lineseries->append(QPoint(0,4));
64 64 lineseries->append(QPoint(1,15));
65 65 lineseries->append(QPoint(2,20));
66 66 lineseries->append(QPoint(3,4));
67 67 lineseries->append(QPoint(4,12));
68 68 lineseries->append(QPoint(5,17));
69 69 //![8]
70 70
71 71 //![3]
72 72 QChart* chart = new QChart();
73 73 chart->addSeries(barseries);
74 74 chart->addSeries(lineseries);
75 75 chart->setTitle("Line and barchart example");
76 76 //![3]
77 77
78 78 //![4]
79 79 QStringList categories;
80 80 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
81 QBarCategoriesAxis* axisX = new QBarCategoriesAxis();
81 QBarCategoryAxis* axisX = new QBarCategoryAxis();
82 82 axisX->append(categories);
83 83 chart->setAxisX(axisX,lineseries);
84 84 chart->setAxisX(axisX,barseries);
85 85 axisX->setRange(QString("Jan"),QString("Jun"));
86 86
87 87 QValueAxis* axisY = new QValueAxis();
88 88 chart->setAxisY(axisY,lineseries);
89 89 chart->setAxisY(axisY,barseries);
90 90 axisY->setRange(0,20);
91 91 //![4]
92 92
93 93 //![5]
94 94 chart->legend()->setVisible(true);
95 95 chart->legend()->setAlignment(Qt::AlignBottom);
96 96 //![5]
97 97
98 98 //![6]
99 99 QChartView* chartView = new QChartView(chart);
100 100 chartView->setRenderHint(QPainter::Antialiasing);
101 101 //![6]
102 102
103 103 //![7]
104 104 QMainWindow window;
105 105 window.setCentralWidget(chartView);
106 106 window.resize(400, 300);
107 107 window.show();
108 108 //![7]
109 109
110 110 return a.exec();
111 111 }
Show file before | Show file after | Hide comments
@@ -1,92 +1,92
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QPercentBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28
29 29 QTCOMMERCIALCHART_USE_NAMESPACE
30 30
31 31 int main(int argc, char *argv[])
32 32 {
33 33 QApplication a(argc, argv);
34 34
35 35 //![1]
36 36 QBarSet *set0 = new QBarSet("Jane");
37 37 QBarSet *set1 = new QBarSet("John");
38 38 QBarSet *set2 = new QBarSet("Axel");
39 39 QBarSet *set3 = new QBarSet("Mary");
40 40 QBarSet *set4 = new QBarSet("Samantha");
41 41
42 42 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
43 43 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
44 44 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
45 45 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
46 46 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
47 47 //![1]
48 48
49 49 //![2]
50 50 QPercentBarSeries* series = new QPercentBarSeries();
51 51 series->append(set0);
52 52 series->append(set1);
53 53 series->append(set2);
54 54 series->append(set3);
55 55 series->append(set4);
56 56 //![2]
57 57
58 58 //![3]
59 59 QChart* chart = new QChart();
60 60 chart->addSeries(series);
61 61 chart->setTitle("Simple percentbarchart example");
62 62 //![3]
63 63
64 64 //![4]
65 65 QStringList categories;
66 66 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
67 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
67 QBarCategoryAxis* axis = new QBarCategoryAxis();
68 68 axis->append(categories);
69 69 chart->createDefaultAxes();
70 70 chart->setAxisX(axis,series);
71 71 //![4]
72 72
73 73 //![5]
74 74 chart->legend()->setVisible(true);
75 75 chart->legend()->setAlignment(Qt::AlignBottom);
76 76 //![5]
77 77
78 78 //![6]
79 79 QChartView* chartView = new QChartView(chart);
80 80 chartView->setRenderHint(QPainter::Antialiasing);
81 81 //![6]
82 82
83 83 //![7]
84 84 QMainWindow window;
85 85 window.setCentralWidget(chartView);
86 86 window.resize(400, 300);
87 87 window.show();
88 88 //![7]
89 89
90 90 return a.exec();
91 91 }
92 92
Show file before | Show file after | Hide comments
@@ -1,93 +1,93
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28 #include <QHorizontalBarSeries>
29 29
30 30 QTCOMMERCIALCHART_USE_NAMESPACE
31 31
32 32 int main(int argc, char *argv[])
33 33 {
34 34 QApplication a(argc, argv);
35 35
36 36 //![1]
37 37 QBarSet *male = new QBarSet("Male");
38 38 QBarSet *female = new QBarSet("Female");
39 39
40 40 // From wikipedia
41 41 *male << -145596 << -149894 << -167327 << -164118 << -170710 << -169408 << -158395 << -176975 << -191803 << -191198 << -196815
42 42 << -207826 << -145517 << -113204 << -90986 << -70909 << -40013 << -15887 << -5769;
43 43
44 44 *female << 139353 << 143522 << 161212 << 156824 << 163226 << 161766 << 150595 << 170779 << 185979 << 187897 << 196158
45 45 << 209062 << 152460 << 129230 << 114778 << 109611 << 83845 << 44605 << 22328;
46 46
47 47 //![1]
48 48
49 49 //![2]
50 50 QHorizontalBarSeries *series = new QHorizontalBarSeries();
51 51 series->append(male);
52 52 series->append(female);
53 53 series->setBarWidth(0.5);
54 54 series->setGrouping(false);
55 55 //![2]
56 56
57 57 //![3]
58 58 QChart* chart = new QChart();
59 59 chart->addSeries(series);
60 60 chart->setTitle("Population of Finland in 2005 by age group");
61 61 chart->createDefaultAxes();
62 62 chart->setAnimationOptions(QChart::SeriesAnimations);
63 63 //![3]
64 64
65 65 //![4]
66 66 QStringList categories;
67 67 categories << "0-4" << "5-9" << "10-14" << "15-19" << "20-24" << "25-29" << "30-34" << "35-39" << "40-44" << "45-49"
68 68 << "50-54" << "55-59" << "60-64" << "65-69" << "70-74" << "75-79" << "80-84" << "85-89" << "90-";
69 69
70 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
70 QBarCategoryAxis* axis = new QBarCategoryAxis();
71 71 axis->append(categories);
72 72 chart->setAxisY(axis,series);
73 73 //![4]
74 74
75 75 //![5]
76 76 chart->legend()->setVisible(true);
77 77 chart->legend()->setAlignment(Qt::AlignBottom);
78 78 //![5]
79 79
80 80 //![6]
81 81 QChartView* chartView = new QChartView(chart);
82 82 chartView->setRenderHint(QPainter::Antialiasing);
83 83 //![6]
84 84
85 85 //![7]
86 86 QMainWindow window;
87 87 window.setCentralWidget(chartView);
88 88 window.resize(400, 800);
89 89 window.show();
90 90 //![7]
91 91
92 92 return a.exec();
93 93 }
Show file before | Show file after | Hide comments
@@ -1,89 +1,89
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "chart.h"
22 22 #include "chartview.h"
23 23 #include <QApplication>
24 24 #include <QMainWindow>
25 25 #include <qmath.h>
26 26 #include <QBarSeries>
27 27 #include <QBarSet>
28 28 #include <QBarCategoriesAxis>
29 29 #include <QLineSeries>
30 30 #include <QHorizontalBarSeries>
31 31
32 32 QTCOMMERCIALCHART_USE_NAMESPACE
33 33
34 34 int main(int argc, char *argv[])
35 35 {
36 36 QApplication a(argc, argv);
37 37
38 38 QLineSeries* series = new QLineSeries();
39 39 for (int i = 0; i < 500; i++) {
40 40 QPointF p((qreal) i, qSin(M_PI / 50 * i) * 100);
41 41 p.ry() += qrand() % 20;
42 42 *series << p;
43 43 }
44 44
45 45 QBarSet *set0 = new QBarSet("Jane");
46 46 QBarSet *set1 = new QBarSet("John");
47 47 QBarSet *set2 = new QBarSet("Axel");
48 48 QBarSet *set3 = new QBarSet("Mary");
49 49 QBarSet *set4 = new QBarSet("Samantha");
50 50
51 51 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
52 52 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
53 53 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
54 54 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
55 55 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
56 56
57 57 //QHorizontalBarSeries* series2 = new QHorizontalBarSeries();
58 58 QBarSeries* series2 = new QBarSeries();
59 59 series2->append(set0);
60 60 series2->append(set1);
61 61 series2->append(set2);
62 62 series2->append(set3);
63 63 series2->append(set4);
64 64
65 65 Chart* chart = new Chart();
66 66 // chart->addSeries(series);
67 67 chart->addSeries(series2);
68 68 chart->setTitle("Scroll in/out example");
69 69 chart->legend()->hide();
70 70 chart->createDefaultAxes();
71 71
72 72 QStringList categories;
73 73 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
74 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
74 QBarCategoryAxis* axis = new QBarCategoryAxis();
75 75 axis->append(categories);
76 76 chart->setAxisX(axis, series2);
77 77
78 78 ChartView* chartView = new ChartView(chart);
79 79 chartView->setRenderHint(QPainter::Antialiasing);
80 80
81 81 QMainWindow window;
82 82 window.setCentralWidget(chartView);
83 83 window.resize(400, 300);
84 84 window.grabGesture(Qt::PanGesture);
85 85 window.grabGesture(Qt::PinchGesture);
86 86 window.show();
87 87
88 88 return a.exec();
89 89 }
Show file before | Show file after | Hide comments
@@ -1,92 +1,92
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QApplication>
22 22 #include <QMainWindow>
23 23 #include <QChartView>
24 24 #include <QStackedBarSeries>
25 25 #include <QBarSet>
26 26 #include <QLegend>
27 27 #include <QBarCategoriesAxis>
28 28
29 29 QTCOMMERCIALCHART_USE_NAMESPACE
30 30
31 31 int main(int argc, char *argv[])
32 32 {
33 33 QApplication a(argc, argv);
34 34
35 35 //![1]
36 36 QBarSet *set0 = new QBarSet("Jane");
37 37 QBarSet *set1 = new QBarSet("John");
38 38 QBarSet *set2 = new QBarSet("Axel");
39 39 QBarSet *set3 = new QBarSet("Mary");
40 40 QBarSet *set4 = new QBarSet("Samantha");
41 41
42 42 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
43 43 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
44 44 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
45 45 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
46 46 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
47 47 //![1]
48 48
49 49 //![2]
50 50 QStackedBarSeries* series = new QStackedBarSeries();
51 51 series->append(set0);
52 52 series->append(set1);
53 53 series->append(set2);
54 54 series->append(set3);
55 55 series->append(set4);
56 56 //![2]
57 57
58 58 //![3]
59 59 QChart* chart = new QChart();
60 60 chart->addSeries(series);
61 61 chart->setTitle("Simple stackedbarchart example");
62 62 chart->createDefaultAxes();
63 63 //![3]
64 64
65 65 //![4]
66 66 QStringList categories;
67 67 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
68 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
68 QBarCategoryAxis* axis = new QBarCategoryAxis();
69 69 axis->append(categories);
70 70 chart->setAxisX(axis,series);
71 71 //![4]
72 72
73 73 //![5]
74 74 chart->legend()->setVisible(true);
75 75 chart->legend()->setAlignment(Qt::AlignBottom);
76 76 //![5]
77 77
78 78 //![6]
79 79 QChartView* chartView = new QChartView(chart);
80 80 chartView->setRenderHint(QPainter::Antialiasing);
81 81 //![6]
82 82
83 83 //![7]
84 84 QMainWindow window;
85 85 window.setCentralWidget(chartView);
86 86 window.resize(400, 300);
87 87 window.show();
88 88 //![7]
89 89
90 90 return a.exec();
91 91 }
92 92
Show file before | Show file after | Hide comments
@@ -1,59 +1,59
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "drilldownchart.h"
22 22 #include <QBarCategoriesAxis>
23 23
24 24 QTCOMMERCIALCHART_USE_NAMESPACE
25 25
26 26 DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
27 27 : QChart(parent, wFlags)
28 28 ,m_currentSeries(0)
29 29 {
30 30 }
31 31
32 32 void DrilldownChart::changeSeries(DrilldownBarSeries *series)
33 33 {
34 34 if (m_currentSeries) {
35 35 removeSeries(m_currentSeries);
36 36 }
37 37
38 38 m_currentSeries = series;
39 39
40 40 // Reset axis
41 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
41 QBarCategoryAxis* axis = new QBarCategoryAxis();
42 42 axis->append(m_currentSeries->categories());
43 43
44 44 addSeries(series);
45 45
46 46 createDefaultAxes();
47 47 setAxisX(axis,series);
48 48
49 49 setTitle(series->name());
50 50 }
51 51
52 52 void DrilldownChart::handleClicked(int index, QBarSet *barset)
53 53 {
54 54 Q_UNUSED(barset)
55 55 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
56 56 changeSeries(series->drilldownSeries(index));
57 57 }
58 58
59 59 #include "moc_drilldownchart.cpp"
Show file before | Show file after | Hide comments
@@ -1,101 +1,101
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QtDeclarative/qdeclarativeextensionplugin.h>
22 22 #include <QtDeclarative/qdeclarative.h>
23 23 #include "qchart.h"
24 24 #include "qabstractaxis.h"
25 25 #include "qvalueaxis.h"
26 26 #include "qbarcategoriesaxis.h"
27 27 #include "declarativechart.h"
28 28 #include "declarativexypoint.h"
29 29 #include "declarativelineseries.h"
30 30 #include "declarativesplineseries.h"
31 31 #include "declarativeareaseries.h"
32 32 #include "declarativescatterseries.h"
33 33 #include "declarativebarseries.h"
34 34 #include "declarativepieseries.h"
35 35 #include "qvxymodelmapper.h"
36 36 #include "qhxymodelmapper.h"
37 37 #include "qhpiemodelmapper.h"
38 38 #include "qvpiemodelmapper.h"
39 39 #include "qhbarmodelmapper.h"
40 40 #include "qvbarmodelmapper.h"
41 41 #include <QAbstractItemModel>
42 42
43 43 QTCOMMERCIALCHART_BEGIN_NAMESPACE
44 44
45 45 class ChartQmlPlugin : public QDeclarativeExtensionPlugin
46 46 {
47 47 Q_OBJECT
48 48 public:
49 49 virtual void registerTypes(const char *uri)
50 50 {
51 51 Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
52 52
53 53 qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
54 54 qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
55 55 qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
56 56 qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
57 57 qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
58 58 qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
59 59 qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
60 60 qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
61 61 qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
62 62 qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
63 63 qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
64 64 qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
65 65 qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
66 66 qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
67 67 qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
68 68 qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
69 69 qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
70 70 qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
71 71 qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
72 qmlRegisterType<QBarCategoriesAxis>(uri, 1, 0, "BarCategoriesAxis");
72 qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
73 73
74 74 qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
75 75 QLatin1String("Trying to create uncreatable: Legend."));
76 76 qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
77 77 QLatin1String("Trying to create uncreatable: XYSeries."));
78 78 qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
79 79 QLatin1String("Trying to create uncreatable: AbstractItemModel."));
80 80 qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
81 81 QLatin1String("Trying to create uncreatable: XYModelMapper."));
82 82 qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
83 83 QLatin1String("Trying to create uncreatable: PieModelMapper."));
84 84 qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
85 85 QLatin1String("Trying to create uncreatable: BarModelMapper."));
86 86 qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
87 87 QLatin1String("Trying to create uncreatable: AbstractSeries."));
88 88 qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
89 89 QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
90 90 qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
91 91 QLatin1String("Trying to create uncreatable: AbstractAxis."));
92 92 }
93 93 };
94 94
95 95 #include "plugin.moc"
96 96
97 97 QTCOMMERCIALCHART_END_NAMESPACE
98 98
99 99 QTCOMMERCIALCHART_USE_NAMESPACE
100 100
101 101 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
Show file before | Show file after | Hide comments
@@ -1,159 +1,159
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "chartcategoriesaxisx_p.h"
22 22 #include "chartpresenter_p.h"
23 23 #include "qbarcategoriesaxis_p.h"
24 24 #include <QDebug>
25 25 #include <qmath.h>
26 26
27 27 static int label_padding = 5;
28 28
29 29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 30
31 ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
31 ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
32 32 m_categoriesAxis(axis)
33 33 {
34 34
35 35 }
36 36
37 37 ChartCategoriesAxisX::~ChartCategoriesAxisX()
38 38 {
39 39 }
40 40
41 41 QVector<qreal> ChartCategoriesAxisX::calculateLayout() const
42 42 {
43 43 int count = m_categoriesAxis->d_ptr->count();
44 44
45 45 Q_ASSERT(count>=1);
46 46
47 47 QVector<qreal> points;
48 48 points.resize(count+2);
49 49
50 50 const qreal delta = m_rect.width()/(count);
51 51 qreal offset =-m_min-0.5;
52 52
53 53 if(offset<=0) {
54 54 offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta) + delta;
55 55 }
56 56 else {
57 57 offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta);
58 58 }
59 59
60 60 points[0] = m_rect.left();
61 61 points[count+1] = m_rect.right();
62 62
63 63 for (int i = 0; i < count; ++i) {
64 64 qreal x = offset + i * delta + m_rect.left();
65 65 points[i+1] = x;
66 66 }
67 67 return points;
68 68 }
69 69
70 70 QStringList ChartCategoriesAxisX::createCategoryLabels(const QVector<qreal>& layout) const
71 71 {
72 72 QStringList result;
73 73 qreal d = (m_max - m_min)/m_rect.width();
74 74 for (int i = 0;i < layout.count()-1; ++i) {
75 75 qreal x = qFloor((((layout[i+1] + layout[i])/2-m_rect.left())*d + m_min+0.5));
76 76 if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
77 77 result << m_categoriesAxis->categories().at(x);
78 78 }
79 79 else {
80 80 // No label for x coordinate
81 81 result << "";
82 82 }
83 83 }
84 84 result << "";
85 85 return result;
86 86 }
87 87
88 88
89 89 void ChartCategoriesAxisX::updateGeometry()
90 90 {
91 91 const QVector<qreal>& layout = ChartAxis::layout();
92 92
93 93 m_minWidth = 0;
94 94 m_minHeight = 0;
95 95
96 96 if(layout.isEmpty()) return;
97 97
98 98 QStringList ticksList = createCategoryLabels(layout);
99 99
100 100 QList<QGraphicsItem *> lines = m_grid->childItems();
101 101 QList<QGraphicsItem *> labels = m_labels->childItems();
102 102 QList<QGraphicsItem *> shades = m_shades->childItems();
103 103 QList<QGraphicsItem *> axis = m_arrow->childItems();
104 104
105 105 Q_ASSERT(labels.size() == ticksList.size());
106 106 Q_ASSERT(layout.size() == ticksList.size());
107 107
108 108 const qreal delta = m_rect.width()/(m_categoriesAxis->d_ptr->count());
109 109
110 110 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
111 111 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
112 112
113 113 qreal width = m_rect.left();
114 114 for (int i = 0; i < layout.size(); ++i) {
115 115 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
116 116 lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
117 117 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
118 118 labelItem->setText(ticksList.at(i));
119 119 const QRectF& rect = labelItem->boundingRect();
120 120 QPointF center = rect.center();
121 121 labelItem->setTransformOriginPoint(center.x(), center.y());
122 122
123 123 if(i==0){
124 124 labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
125 125 }else{
126 126 labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
127 127 }
128 128
129 129 if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()>m_rect.right()) {
130 130 labelItem->setVisible(false);
131 131 }
132 132 else {
133 133 labelItem->setVisible(true);
134 134 width=rect.width()+labelItem->pos().x();
135 135 }
136 136
137 137 m_minWidth+=rect.width();
138 138 m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
139 139
140 140 if ((i+1)%2 && i>1) {
141 141 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
142 142 rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
143 143 }
144 144 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
145 145 lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
146 146 }
147 147 }
148 148
149 149 void ChartCategoriesAxisX::handleAxisUpdated()
150 150 {
151 151 if(m_categoriesAxis->categories()!=m_categories)
152 152 {
153 153 m_categories=m_categoriesAxis->categories();
154 154 if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) updateGeometry();
155 155 }
156 156 ChartAxis::handleAxisUpdated();
157 157 }
158 158
159 159 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,64 +1,64
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef CHARTCATEGORIESAXISX_H
31 31 #define CHARTCATEGORIESAXISX_H
32 32
33 33 #include "chartaxis_p.h"
34 34
35 35 QTCOMMERCIALCHART_BEGIN_NAMESPACE
36 36
37 37 class QAbstractAxis;
38 38 class ChartPresenter;
39 class QBarCategoriesAxis;
39 class QBarCategoryAxis;
40 40
41 41 class ChartCategoriesAxisX : public ChartAxis
42 42 {
43 43 public:
44 ChartCategoriesAxisX(QBarCategoriesAxis *axis, ChartPresenter *presenter);
44 ChartCategoriesAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter);
45 45 ~ChartCategoriesAxisX();
46 46
47 47 AxisType axisType() const { return X_AXIS;}
48 48
49 49 protected:
50 50 QVector<qreal> calculateLayout() const;
51 51 void updateGeometry();
52 52 private:
53 53 QStringList createCategoryLabels(const QVector<qreal>& layout) const;
54 54 Q_SLOTS
55 55 void handleAxisUpdated();
56 56
57 57 private:
58 58 QStringList m_categories;
59 QBarCategoriesAxis *m_categoriesAxis;
59 QBarCategoryAxis *m_categoriesAxis;
60 60 };
61 61
62 62 QTCOMMERCIALCHART_END_NAMESPACE
63 63
64 64 #endif /* CHARTCATEGORIESAXISX_H */
Show file before | Show file after | Hide comments
@@ -1,160 +1,160
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "chartcategoriesaxisy_p.h"
22 22 #include "chartpresenter_p.h"
23 23 #include "qbarcategoriesaxis_p.h"
24 24 #include <qmath.h>
25 25
26 26 static int label_padding = 5;
27 27
28 28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29 29
30 ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
30 ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
31 31 m_categoriesAxis(axis)
32 32 {
33 33 }
34 34
35 35 ChartCategoriesAxisY::~ChartCategoriesAxisY()
36 36 {
37 37 }
38 38
39 39 QVector<qreal> ChartCategoriesAxisY::calculateLayout() const
40 40 {
41 41 int count = m_categoriesAxis->d_ptr->count();
42 42
43 43 Q_ASSERT(count>=1);
44 44
45 45 QVector<qreal> points;
46 46 points.resize(count+2);
47 47
48 48 const qreal delta = m_rect.height()/(count);
49 49 qreal offset = - m_min - 0.5;
50 50
51 51 if(offset<=0) {
52 52 offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta) + delta;
53 53 }
54 54 else {
55 55 offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta);
56 56 }
57 57
58 58 points[0] = m_rect.bottom();
59 59 points[count+1] = m_rect.top();
60 60
61 61 for (int i = 0; i < count; ++i) {
62 62 int y = m_rect.bottom() - i * delta - offset;
63 63 points[i+1] = y;
64 64 }
65 65 return points;
66 66 }
67 67
68 68 QStringList ChartCategoriesAxisY::createCategoryLabels(const QVector<qreal>& layout) const
69 69 {
70 70 QStringList result;
71 71 qreal d = (m_max - m_min)/m_rect.height();
72 72 for (int i = 0;i < layout.count()-1; ++i) {
73 73 qreal x = qFloor(((m_rect.height()- (layout[i+1] + layout[i])/2 + m_rect.top())*d + m_min+0.5));
74 74 if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
75 75 result << m_categoriesAxis->categories().at(x);
76 76 }
77 77 else {
78 78 // No label for x coordinate
79 79 result << "";
80 80 }
81 81 }
82 82 result << "";
83 83 return result;
84 84 }
85 85
86 86 void ChartCategoriesAxisY::updateGeometry()
87 87 {
88 88 const QVector<qreal>& layout = ChartAxis::layout();
89 89
90 90 m_minWidth = 0;
91 91 m_minHeight = 0;
92 92
93 93 if(layout.isEmpty()) return;
94 94
95 95 QStringList ticksList = createCategoryLabels(layout);
96 96
97 97 QList<QGraphicsItem *> lines = m_grid->childItems();
98 98 QList<QGraphicsItem *> labels = m_labels->childItems();
99 99 QList<QGraphicsItem *> shades = m_shades->childItems();
100 100 QList<QGraphicsItem *> axis = m_arrow->childItems();
101 101
102 102 Q_ASSERT(labels.size() == ticksList.size());
103 103 Q_ASSERT(layout.size() == ticksList.size());
104 104
105 105 const qreal delta = m_rect.height()/(m_categoriesAxis->d_ptr->count());
106 106
107 107 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
108 108 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
109 109
110 110 qreal height = m_rect.bottom();
111 111 for (int i = 0; i < layout.size(); ++i) {
112 112 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
113 113 lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
114 114 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
115 115 labelItem->setText(ticksList.at(i));
116 116 const QRectF& rect = labelItem->boundingRect();
117 117 QPointF center = rect.center();
118 118 labelItem->setTransformOriginPoint(center.x(), center.y());
119 119
120 120 if(i==0) {
121 121 labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
122 122 }
123 123 else {
124 124 labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
125 125 }
126 126
127 127 if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_rect.top()) {
128 128 labelItem->setVisible(false);
129 129 }
130 130 else {
131 131 labelItem->setVisible(true);
132 132 height=labelItem->pos().y();
133 133 }
134 134
135 135 m_minWidth+=rect.width();
136 136 m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
137 137
138 138 if ((i+1)%2 && i>1) {
139 139 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
140 140 rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
141 141 }
142 142 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
143 143 lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
144 144 }
145 145 }
146 146
147 147 void ChartCategoriesAxisY::handleAxisUpdated()
148 148 {
149 149
150 150 if(m_categoriesAxis->categories()!=m_categories)
151 151 {
152 152 m_categories=m_categoriesAxis->categories();
153 153 if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) {
154 154 updateGeometry();
155 155 }
156 156 }
157 157 ChartAxis::handleAxisUpdated();
158 158 }
159 159
160 160 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,63 +1,63
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef CHARTCATEGORIESAXISY_H
31 31 #define CHARTCATEGORIESAXISY_H
32 32
33 33 #include "chartaxis_p.h"
34 34
35 35 QTCOMMERCIALCHART_BEGIN_NAMESPACE
36 36
37 37 class QAbstractAxis;
38 class QBarCategoriesAxis;
38 class QBarCategoryAxis;
39 39 class ChartPresenter;
40 40
41 41 class ChartCategoriesAxisY : public ChartAxis
42 42 {
43 43 public:
44 ChartCategoriesAxisY(QBarCategoriesAxis *axis, ChartPresenter *presenter);
44 ChartCategoriesAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter);
45 45 ~ChartCategoriesAxisY();
46 46
47 47 AxisType axisType() const { return Y_AXIS;}
48 48
49 49 protected:
50 50 QVector<qreal> calculateLayout() const;
51 51 void updateGeometry();
52 52 private:
53 53 QStringList createCategoryLabels(const QVector<qreal>& layout) const;
54 54 Q_SLOTS
55 55 void handleAxisUpdated();
56 56 private:
57 57 QStringList m_categories;
58 QBarCategoriesAxis *m_categoriesAxis;
58 QBarCategoryAxis *m_categoriesAxis;
59 59 };
60 60
61 61 QTCOMMERCIALCHART_END_NAMESPACE
62 62
63 63 #endif /* CHARTCATEGORIESAXISY_H */
Show file before | Show file after | Hide comments
@@ -1,471 +1,471
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "qbarcategoriesaxis.h"
22 22 #include "qbarcategoriesaxis_p.h"
23 23 #include "chartcategoriesaxisx_p.h"
24 24 #include "chartcategoriesaxisy_p.h"
25 25 #include "domain_p.h"
26 26 #include "chartdataset_p.h"
27 27 #include <qmath.h>
28 28
29 29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 30 /*!
31 31 \class QBarCategoriesAxis
32 32 \brief The QBarCategoriesAxis class is used for manipulating chart's axis.
33 33 \mainclass
34 34
35 35 BarCategoriesAxis can be setup to show axis line with tick marks, grid lines and shades.
36 36 Categories are drawn between ticks. Note that you can use this also with lineseries too.
37 37 See the \l {Line and BarChart Example} {Line and BarChart Example} to learn how to do that.
38 38 */
39 39
40 40 /*!
41 41 \qmlclass BarCategoriesAxis QBarCategoriesAxis
42 42 \brief The Axis element is used for manipulating chart's axes.
43 43
44 44 Axis can be setup to show axis line with tick marks, grid lines and shades.
45 45 Categories are drawn between ticks. Note that you can use this also with lineseries too.
46 46
47 47 To access BarCategoriesAxis you can use ChartView API. For example:
48 48 \code
49 49 ChartView {
50 50 BarCategoriesAxis {
51 51 id: categoryAxis
52 52 categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
53 53 }
54 54 // Add a few series...
55 55 }
56 56 \endcode
57 57 */
58 58
59 59 /*!
60 60 \property QBarCategoriesAxis::categories
61 61 Defines the categories of axis
62 62 */
63 63 /*!
64 64 \qmlproperty QStringList BarCategoriesAxis::categories
65 65 Defines the categories of axis
66 66 */
67 67
68 68 /*!
69 69 \property QBarCategoriesAxis::min
70 70 Defines the minimum value on the axis.
71 71 */
72 72 /*!
73 73 \qmlproperty QString BarCategoriesAxis::min
74 74 Defines the minimum value on the axis.
75 75 */
76 76
77 77 /*!
78 78 \property QBarCategoriesAxis::max
79 79 Defines the maximum value on the axis.
80 80 */
81 81 /*!
82 82 \qmlproperty QString BarCategoriesAxis::max
83 83 Defines the maximum value on the axis.
84 84 */
85 85
86 86
87 87 /*!
88 88 \fn void QBarCategoriesAxis::categoriesChanged()
89 89 Axis emits signal when the categories of the axis has changed.
90 90 */
91 91 /*!
92 92 \fn void QBarCategoriesAxis::minChanged(const QString &min)
93 93 Axis emits signal when \a min of axis has changed.
94 94 */
95 95 /*!
96 96 \qmlsignal BarCategoriesAxis::onMinChanged(const QString &min)
97 97 Axis emits signal when \a min of axis has changed.
98 98 */
99 99
100 100 /*!
101 101 \fn void QBarCategoriesAxis::maxChanged(const QString &max)
102 102 Axis emits signal when \a max of axis has changed.
103 103 */
104 104 /*!
105 105 \qmlsignal BarCategoriesAxis::onMaxChanged(const QString &max)
106 106 Axis emits signal when \a max of axis has changed.
107 107 */
108 108
109 109 /*!
110 110 \fn void QBarCategoriesAxis::rangeChanged(const QString &min, const QString &max)
111 111 Axis emits signal when \a min or \a max of axis has changed.
112 112 */
113 113
114 114 /*!
115 115 Constructs an axis object which is a child of \a parent.
116 116 */
117 QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
118 QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
117 QBarCategoryAxis::QBarCategoryAxis(QObject *parent):
118 QAbstractAxis(*new QBarCategoryAxisPrivate(this),parent)
119 119 {
120 120 }
121 121
122 122 /*!
123 123 Destroys the object
124 124 */
125 QBarCategoriesAxis::~QBarCategoriesAxis()
125 QBarCategoryAxis::~QBarCategoryAxis()
126 126 {
127 Q_D(QBarCategoriesAxis);
127 Q_D(QBarCategoryAxis);
128 128 if(d->m_dataset){
129 129 d->m_dataset->removeAxis(this);
130 130 }
131 131 }
132 132
133 133 /*!
134 134 \internal
135 135 */
136 QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
136 QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
137 137 {
138 138
139 139 }
140 140
141 141 /*!
142 142 Appends \a categories to axis
143 143 */
144 void QBarCategoriesAxis::append(const QStringList &categories)
144 void QBarCategoryAxis::append(const QStringList &categories)
145 145 {
146 146 if(categories.isEmpty()) return;
147 147
148 Q_D(QBarCategoriesAxis);
148 Q_D(QBarCategoryAxis);
149 149 if (d->m_categories.isEmpty()) {
150 150 d->m_categories.append(categories);
151 151 setRange(categories.first(),categories.last());
152 152 }else{
153 153 d->m_categories.append(categories);
154 154 d->emitUpdated();
155 155 }
156 156 emit categoriesChanged();
157 157 }
158 158
159 159 /*!
160 160 Appends \a category to axis
161 161 */
162 void QBarCategoriesAxis::append(const QString &category)
162 void QBarCategoryAxis::append(const QString &category)
163 163 {
164 Q_D(QBarCategoriesAxis);
164 Q_D(QBarCategoryAxis);
165 165 if (d->m_categories.isEmpty()) {
166 166 d->m_categories.append(category);
167 167 setRange(category,category);
168 168 }else{
169 169 d->m_categories.append(category);
170 170 d->emitUpdated();
171 171 }
172 172 emit categoriesChanged();
173 173 }
174 174
175 175 /*!
176 176 Removes \a category from axis
177 177 */
178 void QBarCategoriesAxis::remove(const QString &category)
178 void QBarCategoryAxis::remove(const QString &category)
179 179 {
180 Q_D(QBarCategoriesAxis);
180 Q_D(QBarCategoryAxis);
181 181 if (d->m_categories.contains(category)) {
182 182 d->m_categories.removeAt(d->m_categories.indexOf(category));
183 183 if(!d->m_categories.isEmpty())
184 184 setRange(d->m_categories.first(),d->m_categories.last());
185 185 else
186 186 setRange(QString::null,QString::null);
187 187 emit categoriesChanged();
188 188 }
189 189 }
190 190
191 191 /*!
192 192 Inserts \a category to axis at \a index
193 193 */
194 void QBarCategoriesAxis::insert(int index, const QString &category)
194 void QBarCategoryAxis::insert(int index, const QString &category)
195 195 {
196 Q_D(QBarCategoriesAxis);
196 Q_D(QBarCategoryAxis);
197 197 if (d->m_categories.isEmpty()) {
198 198 d->m_categories.insert(index,category);
199 199 setRange(category,category);
200 200 }else{
201 201 d->m_categories.insert(index,category);
202 202 d->emitUpdated();
203 203 }
204 204 emit categoriesChanged();
205 205 }
206 206
207 207 /*!
208 208 Replaces \a oldCategory with \a newCategory.
209 209 If \a oldCategory does not exits on the axis nothing is done.
210 210 */
211 void QBarCategoriesAxis::replace(const QString &oldCategory, const QString &newCategory)
211 void QBarCategoryAxis::replace(const QString &oldCategory, const QString &newCategory)
212 212 {
213 Q_D(QBarCategoriesAxis);
213 Q_D(QBarCategoryAxis);
214 214 int pos = d->m_categories.indexOf(oldCategory);
215 215 if (pos != -1) {
216 216 d->m_categories.replace(pos, newCategory);
217 217 d->emitUpdated();
218 218 emit categoriesChanged();
219 219 }
220 220 }
221 221
222 222 /*!
223 223 Removes all categories.
224 224 */
225 void QBarCategoriesAxis::clear()
225 void QBarCategoryAxis::clear()
226 226 {
227 Q_D(QBarCategoriesAxis);
227 Q_D(QBarCategoryAxis);
228 228 d->m_categories.clear();
229 229 setRange(QString::null,QString::null);
230 230 emit categoriesChanged();
231 231 }
232 232
233 void QBarCategoriesAxis::setCategories(const QStringList &categories)
233 void QBarCategoryAxis::setCategories(const QStringList &categories)
234 234 {
235 Q_D(QBarCategoriesAxis);
235 Q_D(QBarCategoryAxis);
236 236 if(d->m_categories!=categories) {
237 237 d->m_categories = categories;
238 238 setRange(categories.first(),categories.last());
239 239 emit categoriesChanged();
240 240 }
241 241 }
242 242
243 QStringList QBarCategoriesAxis::categories()
243 QStringList QBarCategoryAxis::categories()
244 244 {
245 Q_D(QBarCategoriesAxis);
245 Q_D(QBarCategoryAxis);
246 246 return d->m_categories;
247 247 }
248 248
249 249 /*!
250 250 Returns number of categories.
251 251 */
252 int QBarCategoriesAxis::count() const
252 int QBarCategoryAxis::count() const
253 253 {
254 Q_D(const QBarCategoriesAxis);
254 Q_D(const QBarCategoryAxis);
255 255 return d->m_categories.count();
256 256 }
257 257
258 258 /*!
259 259 Returns category at \a index. Index must be valid.
260 260 */
261 QString QBarCategoriesAxis::at(int index) const
261 QString QBarCategoryAxis::at(int index) const
262 262 {
263 Q_D(const QBarCategoriesAxis);
263 Q_D(const QBarCategoryAxis);
264 264 return d->m_categories.at(index);
265 265 }
266 266
267 267 /*!
268 268 Sets minimum category to \a min.
269 269 */
270 void QBarCategoriesAxis::setMin(const QString& min)
270 void QBarCategoryAxis::setMin(const QString& min)
271 271 {
272 Q_D(QBarCategoriesAxis);
272 Q_D(QBarCategoryAxis);
273 273 setRange(min,d->m_maxCategory);
274 274 }
275 275
276 276 /*!
277 277 Returns minimum category.
278 278 */
279 QString QBarCategoriesAxis::min() const
279 QString QBarCategoryAxis::min() const
280 280 {
281 Q_D(const QBarCategoriesAxis);
281 Q_D(const QBarCategoryAxis);
282 282 return d->m_minCategory;
283 283 }
284 284
285 285 /*!
286 286 Sets maximum category to \a max.
287 287 */
288 void QBarCategoriesAxis::setMax(const QString& max)
288 void QBarCategoryAxis::setMax(const QString& max)
289 289 {
290 Q_D(QBarCategoriesAxis);
290 Q_D(QBarCategoryAxis);
291 291 setRange(d->m_minCategory,max);
292 292 }
293 293
294 294 /*!
295 295 Returns maximum category
296 296 */
297 QString QBarCategoriesAxis::max() const
297 QString QBarCategoryAxis::max() const
298 298 {
299 Q_D(const QBarCategoriesAxis);
299 Q_D(const QBarCategoryAxis);
300 300 return d->m_maxCategory;
301 301 }
302 302
303 303 /*!
304 304 Sets range from \a minCategory to \a maxCategory
305 305 */
306 void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
306 void QBarCategoryAxis::setRange(const QString& minCategory, const QString& maxCategory)
307 307 {
308 Q_D(QBarCategoriesAxis);
308 Q_D(QBarCategoryAxis);
309 309
310 310 bool changed = false;
311 311
312 312 //special case
313 313 if(minCategory.isNull() && maxCategory.isNull()){
314 314 d->m_minCategory = minCategory;
315 315 d->m_maxCategory = maxCategory;
316 316 d->m_min = 0;
317 317 d->m_max = 0;
318 318 emit minChanged(minCategory);
319 319 emit maxChanged(maxCategory);
320 320 d->m_count=0;
321 321 emit rangeChanged(d->m_minCategory,d->m_maxCategory);
322 322 d->emitUpdated();
323 323 }
324 324
325 325 if(d->m_categories.indexOf(d->m_maxCategory)<d->m_categories.indexOf(d->m_minCategory)) return;
326 326
327 327 if (!minCategory.isEmpty() && d->m_minCategory!=minCategory && d->m_categories.contains(minCategory)) {
328 328 d->m_minCategory = minCategory;
329 329 d->m_min = d->m_categories.indexOf(d->m_minCategory) - 0.5;
330 330 changed = true;
331 331 emit minChanged(minCategory);
332 332 }
333 333
334 334 if (!maxCategory.isEmpty() && d->m_maxCategory!=maxCategory && d->m_categories.contains(maxCategory)) {
335 335 d->m_maxCategory = maxCategory;
336 336 d->m_max = d->m_categories.indexOf(d->m_maxCategory) + 0.5;
337 337 changed = true;
338 338 emit maxChanged(maxCategory);
339 339 }
340 340
341 341 if (changed) {
342 342 d->m_count=d->m_max - d->m_min;
343 343 emit rangeChanged(d->m_minCategory,d->m_maxCategory);
344 344 d->emitUpdated();
345 345 }
346 346 }
347 347
348 348 /*!
349 349 Returns the type of the axis
350 350 */
351 QAbstractAxis::AxisType QBarCategoriesAxis::type() const
351 QAbstractAxis::AxisType QBarCategoryAxis::type() const
352 352 {
353 353 return AxisTypeCategories;
354 354 }
355 355
356 356 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
357 357
358 QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
358 QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis* q):
359 359 QAbstractAxisPrivate(q),
360 360 m_min(0.0),
361 361 m_max(0.0),
362 362 m_count(0)
363 363 {
364 364
365 365 }
366 366
367 QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
367 QBarCategoryAxisPrivate::~QBarCategoryAxisPrivate()
368 368 {
369 369
370 370 }
371 371
372 void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
372 void QBarCategoryAxisPrivate::setMin(const QVariant &min)
373 373 {
374 374 setRange(min,m_maxCategory);
375 375 }
376 376
377 void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
377 void QBarCategoryAxisPrivate::setMax(const QVariant &max)
378 378 {
379 379 setRange(m_minCategory,max);
380 380 }
381 381
382 void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
382 void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)
383 383 {
384 Q_Q(QBarCategoriesAxis);
384 Q_Q(QBarCategoryAxis);
385 385 QString value1 = min.toString();
386 386 QString value2 = max.toString();
387 387 q->setRange(value1,value2);
388 388 }
389 389
390 void QBarCategoriesAxisPrivate::handleDomainUpdated()
390 void QBarCategoryAxisPrivate::handleDomainUpdated()
391 391 {
392 Q_Q(QBarCategoriesAxis);
392 Q_Q(QBarCategoryAxis);
393 393 Domain* domain = qobject_cast<Domain*>(sender());
394 394
395 395 if(m_orientation==Qt::Horizontal) {
396 396 m_min = domain->minX();
397 397 m_max = domain->maxX();
398 398 }
399 399 else if(m_orientation==Qt::Vertical) {
400 400 m_min = domain->minY();
401 401 m_max = domain->maxY();
402 402 }
403 403
404 404 bool changed = false;
405 405
406 406 int min = m_min + 0.5;
407 407 if(min>=0 && min<m_categories.count()) {
408 408 QString minCategory = m_categories.at(min);
409 409 if(m_minCategory!=minCategory && !minCategory.isEmpty()) {
410 410 m_minCategory=minCategory;
411 411 changed=true;
412 412 emit q->minChanged(minCategory);
413 413 }
414 414 }
415 415 int max = m_max - 0.5;
416 416 if(max>=0 && max<m_categories.count()) {
417 417 QString maxCategory = m_categories.at(max);
418 418 if(m_maxCategory!=maxCategory && !maxCategory.isEmpty()) {
419 419 m_maxCategory=maxCategory;
420 420 emit q->maxChanged(maxCategory);
421 421 }
422 422 }
423 423
424 424 if (changed) {
425 425 emit q->rangeChanged(m_minCategory,m_maxCategory);
426 426 }
427 427 }
428 428
429 ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
429 ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
430 430 {
431 Q_Q(QBarCategoriesAxis);
431 Q_Q(QBarCategoryAxis);
432 432 if(m_orientation == Qt::Vertical){
433 433 return new ChartCategoriesAxisY(q,presenter);
434 434 }else{
435 435 return new ChartCategoriesAxisX(q,presenter);
436 436 }
437 437 }
438 438
439 void QBarCategoriesAxisPrivate::intializeDomain(Domain* domain)
439 void QBarCategoryAxisPrivate::intializeDomain(Domain* domain)
440 440 {
441 441
442 Q_Q(QBarCategoriesAxis);
442 Q_Q(QBarCategoryAxis);
443 443 if(m_max==m_min) {
444 444 int min;
445 445 int max;
446 446 if(m_orientation==Qt::Vertical) {
447 447 min = domain->minY() + 0.5;
448 448 max = domain->maxY() - 0.5;
449 449 }
450 450 else {
451 451 min = domain->minX() + 0.5;
452 452 max = domain->maxX() - 0.5;
453 453 }
454 454
455 455 if(min>0 && min<m_categories.count() && max>0 && max<m_categories.count())
456 456 q->setRange(m_categories.at(min),m_categories.at(max));
457 457 }
458 458 else {
459 459 if(m_orientation==Qt::Vertical) {
460 460 domain->setRangeY(m_min, m_max);
461 461 }
462 462 else {
463 463 domain->setRangeX(m_min, m_max);
464 464 }
465 465 }
466 466 }
467 467
468 468 #include "moc_qbarcategoriesaxis.cpp"
469 469 #include "moc_qbarcategoriesaxis_p.cpp"
470 470
471 471 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,79 +1,79
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #ifndef QBARCATEGORIESAXIS_H
22 22 #define QBARCATEGORIESAXIS_H
23 23
24 24 #include "qabstractaxis.h"
25 25
26 26 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 class QBarCategoriesAxisPrivate;
28 class QBarCategoryAxisPrivate;
29 29
30 class QTCOMMERCIALCHART_EXPORT QBarCategoriesAxis : public QAbstractAxis
30 class QTCOMMERCIALCHART_EXPORT QBarCategoryAxis : public QAbstractAxis
31 31 {
32 32 Q_OBJECT
33 33 Q_PROPERTY(QStringList categories READ categories WRITE setCategories NOTIFY categoriesChanged)
34 34 Q_PROPERTY(QString min READ min WRITE setMin NOTIFY minChanged)
35 35 Q_PROPERTY(QString max READ max WRITE setMax NOTIFY maxChanged)
36 36
37 37 public:
38 explicit QBarCategoriesAxis(QObject *parent = 0);
39 ~QBarCategoriesAxis();
38 explicit QBarCategoryAxis(QObject *parent = 0);
39 ~QBarCategoryAxis();
40 40
41 41 protected:
42 QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent = 0);
42 QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent = 0);
43 43
44 44 public:
45 45 AxisType type() const;
46 46 void append(const QStringList &categories);
47 47 void append(const QString &category);
48 48 void remove(const QString &category);
49 49 void insert(int index, const QString &category);
50 50 void replace(const QString &oldCategory, const QString &newCategory);
51 51 void clear();
52 52 void setCategories(const QStringList &categories);
53 53 QStringList categories();
54 54 int count() const;
55 55 QString at(int index) const;
56 56
57 57 //range handling
58 58 void setMin(const QString& minCategory);
59 59 QString min() const;
60 60 void setMax(const QString& maxCategory);
61 61 QString max() const;
62 62 void setRange(const QString& minCategory, const QString& maxCategory);
63 63
64 64 Q_SIGNALS:
65 65 void categoriesChanged();
66 66 void minChanged(const QString &min);
67 67 void maxChanged(const QString &max);
68 68 void rangeChanged(const QString &min, const QString &max);
69 69
70 70 private:
71 Q_DECLARE_PRIVATE(QBarCategoriesAxis)
72 Q_DISABLE_COPY(QBarCategoriesAxis)
71 Q_DECLARE_PRIVATE(QBarCategoryAxis)
72 Q_DISABLE_COPY(QBarCategoryAxis)
73 73 friend class ChartCategoriesAxisX;
74 74 friend class ChartCategoriesAxisY;
75 75 };
76 76
77 77 QTCOMMERCIALCHART_END_NAMESPACE
78 78
79 79 #endif // QCATEGORIESAXIS_H
Show file before | Show file after | Hide comments
@@ -1,76 +1,76
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef QBARCATEGORIESAXIS_P_H
31 31 #define QBARCATEGORIESAXIS_P_H
32 32
33 33 #include "qbarcategoriesaxis.h"
34 34 #include "qabstractaxis_p.h"
35 35
36 36 QTCOMMERCIALCHART_BEGIN_NAMESPACE
37 37
38 38 class Domain;
39 39
40 class QBarCategoriesAxisPrivate : public QAbstractAxisPrivate
40 class QBarCategoryAxisPrivate : public QAbstractAxisPrivate
41 41 {
42 42 Q_OBJECT
43 43
44 44 public:
45 QBarCategoriesAxisPrivate(QBarCategoriesAxis *q);
46 ~QBarCategoriesAxisPrivate();
45 QBarCategoryAxisPrivate(QBarCategoryAxis *q);
46 ~QBarCategoryAxisPrivate();
47 47
48 48 public:
49 49 ChartAxis* createGraphics(ChartPresenter* presenter);
50 50 void intializeDomain(Domain* domain);
51 51 void handleDomainUpdated();
52 qreal min() { return m_min;};
53 qreal max() { return m_max;};
54 int count() const { return m_count; };
52 qreal min() { return m_min;}
53 qreal max() { return m_max;}
54 int count() const { return m_count; }
55 55
56 56 private:
57 57 //range handling
58 58 void setMin(const QVariant &min);
59 59 void setMax(const QVariant &max);
60 60 void setRange(const QVariant &min, const QVariant &max);
61 61
62 62 private:
63 63 QStringList m_categories;
64 64 QString m_minCategory;
65 65 QString m_maxCategory;
66 66 qreal m_min;
67 67 qreal m_max;
68 68 int m_count;
69 69
70 70 private:
71 Q_DECLARE_PUBLIC(QBarCategoriesAxis);
71 Q_DECLARE_PUBLIC(QBarCategoryAxis);
72 72 };
73 73
74 74 QTCOMMERCIALCHART_END_NAMESPACE
75 75
76 76 #endif // QBARCATEGORIESAXIS_P_H
Show file before | Show file after | Hide comments
@@ -1,828 +1,828
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "qabstractbarseries.h"
22 22 #include "qabstractbarseries_p.h"
23 23 #include "qbarset.h"
24 24 #include "qbarset_p.h"
25 25 #include "domain_p.h"
26 26 #include "legendmarker_p.h"
27 27 #include "chartdataset_p.h"
28 28 #include "charttheme_p.h"
29 29 #include "qvalueaxis.h"
30 30 #include "qbarcategoriesaxis.h"
31 31
32 32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33 33
34 34 /*!
35 35 \class QAbstractBarSeries
36 36 \brief Series for creating a bar chart
37 37 \mainclass
38 38
39 39 QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
40 40 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
41 41 and y-value is the height of the bar. The category names are ignored with this series and x-axis
42 42 shows the x-values.
43 43
44 44 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
45 45 \image examples_barchart.png
46 46
47 47 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
48 48 */
49 49 /*!
50 50 \qmlclass AbstractBarSeries QAbstractBarSeries
51 51 \inherits QAbstractSeries
52 52
53 53 The following QML shows how to create a simple bar chart:
54 54 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
55 55
56 56 \beginfloatleft
57 57 \image demos_qmlchart6.png
58 58 \endfloat
59 59 \clearfloat
60 60 */
61 61
62 62 /*!
63 63 \property QAbstractBarSeries::barWidth
64 64 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
65 65 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
66 66 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
67 67 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
68 68 \sa QBarSeries
69 69 */
70 70 /*!
71 71 \qmlproperty real AbstractBarSeries::barWidth
72 72 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
73 73 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
74 74 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
75 75 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
76 76 */
77 77
78 78 /*!
79 79 \property QAbstractBarSeries::count
80 80 Holds the number of sets in series.
81 81 */
82 82 /*!
83 83 \qmlproperty int AbstractBarSeries::count
84 84 Holds the number of sets in series.
85 85 */
86 86
87 87 /*!
88 88 \property QAbstractBarSeries::labelsVisible
89 89 Defines the visibility of the labels in series
90 90 */
91 91 /*!
92 92 \qmlproperty bool AbstractBarSeries::labelsVisible
93 93 Defines the visibility of the labels in series
94 94 */
95 95
96 96 /*!
97 97 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
98 98 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
99 99 Clicked bar inside set is indexed by \a index
100 100 */
101 101 /*!
102 102 \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
103 103 The signal is emitted if the user clicks with a mouse on top of BarSet.
104 104 Clicked bar inside set is indexed by \a index
105 105 */
106 106
107 107 /*!
108 108 \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
109 109
110 110 The signal is emitted if mouse is hovered on top of series.
111 111 Parameter \a barset is the pointer of barset, where hover happened.
112 112 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
113 113 */
114 114 /*!
115 115 \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
116 116
117 117 The signal is emitted if mouse is hovered on top of series.
118 118 Parameter \a barset is the pointer of barset, where hover happened.
119 119 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
120 120 */
121 121
122 122 /*!
123 123 \fn void QAbstractBarSeries::countChanged()
124 124 This signal is emitted when barset count has been changed, for example by append or remove.
125 125 */
126 126 /*!
127 127 \qmlsignal AbstractBarSeries::onCountChanged()
128 128 This signal is emitted when barset count has been changed, for example by append or remove.
129 129 */
130 130
131 131 /*!
132 132 \fn void QAbstractBarSeries::labelsVisibleChanged()
133 133 This signal is emitted when labels visibility have changed.
134 134 \sa isLabelsVisible(), setLabelsVisible()
135 135 */
136 136
137 137 /*!
138 138 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
139 139 This signal is emitted when \a sets have been added to the series.
140 140 \sa append(), insert()
141 141 */
142 142 /*!
143 143 \qmlsignal AbstractBarSeries::onAdded(BarSet barset)
144 144 Emitted when \a barset has been added to the series.
145 145 */
146 146
147 147 /*!
148 148 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
149 149 This signal is emitted when \a sets have been removed from the series.
150 150 \sa remove()
151 151 */
152 152 /*!
153 153 \qmlsignal AbstractBarSeries::onRemoved(BarSet barset)
154 154 Emitted when \a barset has been removed from the series.
155 155 */
156 156
157 157 /*!
158 158 \qmlmethod BarSet AbstractBarSeries::at(int index)
159 159 Returns bar set at \a index. Returns null if the index is not valid.
160 160 */
161 161
162 162 /*!
163 163 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
164 164 Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
165 165 For example:
166 166 \code
167 167 myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
168 168 myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
169 169 \endcode
170 170 */
171 171
172 172 /*!
173 173 \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
174 174 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
175 175 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
176 176 appended.
177 177 \sa AbstractBarSeries::append()
178 178 */
179 179
180 180 /*!
181 181 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
182 182 Removes the barset from the series. Returns true if successfull, false otherwise.
183 183 */
184 184
185 185 /*!
186 186 \qmlmethod AbstractBarSeries::clear()
187 187 Removes all barsets from the series.
188 188 */
189 189
190 190 /*!
191 191 This is depreciated constructor.
192 192 */
193 193 QAbstractBarSeries::QAbstractBarSeries(QObject *parent) :
194 194 QAbstractSeries(*(QAbstractBarSeriesPrivate*)(0),parent)
195 195 {
196 196 }
197 197
198 198 /*!
199 199 Destructs abstractbarseries and owned barsets.
200 200 */
201 201 QAbstractBarSeries::~QAbstractBarSeries()
202 202 {
203 203
204 204 }
205 205
206 206 /*!
207 207 \internal
208 208 */
209 209 QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent) :
210 210 QAbstractSeries(d,parent)
211 211 {
212 212 }
213 213
214 214 /*!
215 215 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
216 216 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
217 217 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
218 218 Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
219 219 */
220 220 void QAbstractBarSeries::setBarWidth(qreal width)
221 221 {
222 222 Q_D(QAbstractBarSeries);
223 223 d->setBarWidth(width);
224 224 }
225 225
226 226 /*!
227 227 Returns the width of the bars of the series.
228 228 \sa setBarWidth()
229 229 */
230 230 qreal QAbstractBarSeries::barWidth() const
231 231 {
232 232 Q_D(const QAbstractBarSeries);
233 233 return d->barWidth();
234 234 }
235 235
236 236 /*!
237 237 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
238 238 Returns true, if appending succeeded.
239 239 */
240 240 bool QAbstractBarSeries::append(QBarSet *set)
241 241 {
242 242 Q_D(QAbstractBarSeries);
243 243 bool success = d->append(set);
244 244 if (success) {
245 245 QList<QBarSet*> sets;
246 246 sets.append(set);
247 247 set->setParent(this);
248 248 emit barsetsAdded(sets);
249 249 emit countChanged();
250 250 }
251 251 return success;
252 252 }
253 253
254 254 /*!
255 255 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
256 256 was successful.
257 257 Returns true, if set was removed.
258 258 */
259 259 bool QAbstractBarSeries::remove(QBarSet *set)
260 260 {
261 261 Q_D(QAbstractBarSeries);
262 262 bool success = d->remove(set);
263 263 if (success) {
264 264 QList<QBarSet*> sets;
265 265 sets.append(set);
266 266 set->setParent(0);
267 267 emit barsetsRemoved(sets);
268 268 emit countChanged();
269 269 delete set;
270 270 set = 0;
271 271 }
272 272 return success;
273 273 }
274 274
275 275 /*!
276 276 Takes a single \a set from the series. Does not delete the barset object.
277 277
278 278 NOTE: The series remains as the barset's parent object. You must set the
279 279 parent object to take full ownership.
280 280
281 281 Returns true if take was successfull.
282 282 */
283 283 bool QAbstractBarSeries::take(QBarSet *set)
284 284 {
285 285 Q_D(QAbstractBarSeries);
286 286 bool success = d->remove(set);
287 287 if (success) {
288 288 QList<QBarSet*> sets;
289 289 sets.append(set);
290 290 emit barsetsRemoved(sets);
291 291 emit countChanged();
292 292 }
293 293 return success;
294 294 }
295 295
296 296 /*!
297 297 Adds a list of barsets to series. Takes ownership of \a sets.
298 298 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
299 299 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
300 300 and function returns false.
301 301 */
302 302 bool QAbstractBarSeries::append(QList<QBarSet* > sets)
303 303 {
304 304 Q_D(QAbstractBarSeries);
305 305 bool success = d->append(sets);
306 306 if (success) {
307 307 emit barsetsAdded(sets);
308 308 emit countChanged();
309 309 }
310 310 return success;
311 311 }
312 312
313 313 /*!
314 314 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
315 315 Returns true, if inserting succeeded.
316 316
317 317 */
318 318 bool QAbstractBarSeries::insert(int index, QBarSet *set)
319 319 {
320 320 Q_D(QAbstractBarSeries);
321 321 bool success = d->insert(index, set);
322 322 if (success) {
323 323 QList<QBarSet*> sets;
324 324 sets.append(set);
325 325 emit barsetsAdded(sets);
326 326 emit countChanged();
327 327 }
328 328 return success;
329 329 }
330 330
331 331 /*!
332 332 Removes all barsets from the series. Deletes removed sets.
333 333 */
334 334 void QAbstractBarSeries::clear()
335 335 {
336 336 Q_D(QAbstractBarSeries);
337 337 QList<QBarSet *> sets = barSets();
338 338 bool success = d->remove(sets);
339 339 if (success) {
340 340 emit barsetsRemoved(sets);
341 341 emit countChanged();
342 342 foreach (QBarSet* set, sets) {
343 343 delete set;
344 344 }
345 345 }
346 346 }
347 347
348 348 /*!
349 349 Returns number of sets in series.
350 350 */
351 351 int QAbstractBarSeries::count() const
352 352 {
353 353 Q_D(const QAbstractBarSeries);
354 354 return d->m_barSets.count();
355 355 }
356 356
357 357 /*!
358 358 Returns a list of sets in series. Keeps ownership of sets.
359 359 */
360 360 QList<QBarSet*> QAbstractBarSeries::barSets() const
361 361 {
362 362 Q_D(const QAbstractBarSeries);
363 363 return d->m_barSets;
364 364 }
365 365
366 366 /*!
367 367 Sets the visibility of labels in series to \a visible
368 368 */
369 369 void QAbstractBarSeries::setLabelsVisible(bool visible)
370 370 {
371 371 Q_D(QAbstractBarSeries);
372 372 if (d->m_labelsVisible != visible) {
373 373 d->setLabelsVisible(visible);
374 374 emit labelsVisibleChanged();
375 375 }
376 376 }
377 377
378 378 /*!
379 379 Returns the visibility of labels
380 380 */
381 381 bool QAbstractBarSeries::isLabelsVisible() const
382 382 {
383 383 Q_D(const QAbstractBarSeries);
384 384 return d->m_labelsVisible;
385 385 }
386 386
387 387 void QAbstractBarSeries::setGrouping(bool grouping)
388 388 {
389 389 Q_D(QAbstractBarSeries);
390 390 d->setGrouping(grouping);
391 391 }
392 392
393 393
394 394
395 395 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
396 396
397 397 QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
398 398 QAbstractSeriesPrivate(q),
399 399 m_barWidth(0.5), // Default value is 50% of category width
400 400 m_labelsVisible(false),
401 401 m_visible(true),
402 402 m_grouping(true)
403 403 {
404 404 }
405 405
406 406 int QAbstractBarSeriesPrivate::categoryCount() const
407 407 {
408 408 // No categories defined. return count of longest set.
409 409 int count = 0;
410 410 for (int i=0; i<m_barSets.count(); i++) {
411 411 if (m_barSets.at(i)->count() > count) {
412 412 count = m_barSets.at(i)->count();
413 413 }
414 414 }
415 415
416 416 return count;
417 417 }
418 418
419 419 void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
420 420 {
421 421 if (width < 0.0) {
422 422 width = 0.0;
423 423 }
424 424 m_barWidth = width;
425 425 emit updatedBars();
426 426 }
427 427
428 428 qreal QAbstractBarSeriesPrivate::barWidth() const
429 429 {
430 430 return m_barWidth;
431 431 }
432 432
433 433 QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
434 434 {
435 435 return m_barSets.at(index);
436 436 }
437 437
438 438 void QAbstractBarSeriesPrivate::setVisible(bool visible)
439 439 {
440 440 m_visible = visible;
441 441 emit updatedBars();
442 442 }
443 443
444 444 void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
445 445 {
446 446 m_labelsVisible = visible;
447 447 emit labelsVisibleChanged(visible);
448 448 }
449 449
450 450 void QAbstractBarSeriesPrivate::setGrouping(bool grouping)
451 451 {
452 452 if (m_grouping != grouping) {
453 453 m_grouping = grouping;
454 454 emit updatedBars();
455 455 }
456 456 }
457 457
458 458 qreal QAbstractBarSeriesPrivate::min()
459 459 {
460 460 if (m_barSets.count() <= 0) {
461 461 return 0;
462 462 }
463 463 qreal min = INT_MAX;
464 464
465 465 for (int i = 0; i < m_barSets.count(); i++) {
466 466 int categoryCount = m_barSets.at(i)->count();
467 467 for (int j = 0; j < categoryCount; j++) {
468 468 qreal temp = m_barSets.at(i)->at(j);
469 469 if (temp < min)
470 470 min = temp;
471 471 }
472 472 }
473 473 return min;
474 474 }
475 475
476 476 qreal QAbstractBarSeriesPrivate::max()
477 477 {
478 478 if (m_barSets.count() <= 0) {
479 479 return 0;
480 480 }
481 481 qreal max = INT_MIN;
482 482
483 483 for (int i = 0; i < m_barSets.count(); i++) {
484 484 int categoryCount = m_barSets.at(i)->count();
485 485 for (int j = 0; j < categoryCount; j++) {
486 486 qreal temp = m_barSets.at(i)->at(j);
487 487 if (temp > max)
488 488 max = temp;
489 489 }
490 490 }
491 491
492 492 return max;
493 493 }
494 494
495 495 qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
496 496 {
497 497 if ((set < 0) || (set >= m_barSets.count())) {
498 498 // No set, no value.
499 499 return 0;
500 500 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
501 501 // No category, no value.
502 502 return 0;
503 503 }
504 504
505 505 return m_barSets.at(set)->at(category);
506 506 }
507 507
508 508 qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
509 509 {
510 510 if ((set < 0) || (set >= m_barSets.count())) {
511 511 // No set, no value.
512 512 return 0;
513 513 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
514 514 // No category, no value.
515 515 return 0;
516 516 }
517 517
518 518 qreal value = m_barSets.at(set)->at(category);
519 519 qreal sum = categorySum(category);
520 520 if ( qFuzzyIsNull(sum) ) {
521 521 return 0;
522 522 }
523 523
524 524 return value / sum;
525 525 }
526 526
527 527 qreal QAbstractBarSeriesPrivate::categorySum(int category)
528 528 {
529 529 qreal sum(0);
530 530 int count = m_barSets.count(); // Count sets
531 531 for (int set = 0; set < count; set++) {
532 532 if (category < m_barSets.at(set)->count())
533 533 sum += m_barSets.at(set)->at(category);
534 534 }
535 535 return sum;
536 536 }
537 537
538 538 qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
539 539 {
540 540 qreal sum(0);
541 541 int count = m_barSets.count(); // Count sets
542 542 for (int set = 0; set < count; set++) {
543 543 if (category < m_barSets.at(set)->count())
544 544 sum += qAbs(m_barSets.at(set)->at(category));
545 545 }
546 546 return sum;
547 547 }
548 548
549 549 qreal QAbstractBarSeriesPrivate::maxCategorySum()
550 550 {
551 551 qreal max = INT_MIN;
552 552 int count = categoryCount();
553 553 for (int i = 0; i < count; i++) {
554 554 qreal sum = categorySum(i);
555 555 if (sum > max)
556 556 max = sum;
557 557 }
558 558 return max;
559 559 }
560 560
561 561 qreal QAbstractBarSeriesPrivate::minX()
562 562 {
563 563 if (m_barSets.count() <= 0) {
564 564 return 0;
565 565 }
566 566 qreal min = INT_MAX;
567 567
568 568 for (int i = 0; i < m_barSets.count(); i++) {
569 569 int categoryCount = m_barSets.at(i)->count();
570 570 for (int j = 0; j < categoryCount; j++) {
571 571 qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
572 572 if (temp < min)
573 573 min = temp;
574 574 }
575 575 }
576 576 return min;
577 577 }
578 578
579 579 qreal QAbstractBarSeriesPrivate::maxX()
580 580 {
581 581 if (m_barSets.count() <= 0) {
582 582 return 0;
583 583 }
584 584 qreal max = INT_MIN;
585 585
586 586 for (int i = 0; i < m_barSets.count(); i++) {
587 587 int categoryCount = m_barSets.at(i)->count();
588 588 for (int j = 0; j < categoryCount; j++) {
589 589 qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
590 590 if (temp > max)
591 591 max = temp;
592 592 }
593 593 }
594 594
595 595 return max;
596 596 }
597 597
598 598
599 599 void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
600 600 {
601 601 qreal minX(domain.minX());
602 602 qreal minY(domain.minY());
603 603 qreal maxX(domain.maxX());
604 604 qreal maxY(domain.maxY());
605 605
606 606 qreal seriesMinX = this->minX();
607 607 qreal seriesMaxX = this->maxX();
608 608 qreal y = max();
609 609 minX = qMin(minX, seriesMinX - (qreal)0.5);
610 610 minY = qMin(minY, y);
611 611 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
612 612 maxY = qMax(maxY, y);
613 613
614 614 domain.setRange(minX,maxX,minY,maxY);
615 615 }
616 616
617 617 ChartElement* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
618 618 {
619 619 Q_UNUSED(presenter);
620 620 qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
621 621 return 0;
622 622 }
623 623
624 624 QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
625 625 {
626 626 Q_Q(QAbstractBarSeries);
627 627 QList<LegendMarker*> markers;
628 628 foreach(QBarSet* set, q->barSets()) {
629 629 BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
630 630 markers << marker;
631 631 }
632 632
633 633 return markers;
634 634 }
635 635
636 636 bool QAbstractBarSeriesPrivate::append(QBarSet *set)
637 637 {
638 638 Q_Q(QAbstractBarSeries);
639 639 if ((m_barSets.contains(set)) || (set == 0)) {
640 640 // Fail if set is already in list or set is null.
641 641 return false;
642 642 }
643 643 m_barSets.append(set);
644 644 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
645 645 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
646 646 emit restructuredBars(); // this notifies barchartitem
647 647 if (m_dataset) {
648 648 m_dataset->updateSeries(q); // this notifies legend
649 649 }
650 650 return true;
651 651 }
652 652
653 653 bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
654 654 {
655 655 Q_Q(QAbstractBarSeries);
656 656 if (!m_barSets.contains(set)) {
657 657 // Fail if set is not in list
658 658 return false;
659 659 }
660 660 m_barSets.removeOne(set);
661 661 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
662 662 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
663 663 emit restructuredBars(); // this notifies barchartitem
664 664 if (m_dataset) {
665 665 m_dataset->updateSeries(q); // this notifies legend
666 666 }
667 667 return true;
668 668 }
669 669
670 670 bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
671 671 {
672 672 Q_Q(QAbstractBarSeries);
673 673 foreach (QBarSet* set, sets) {
674 674 if ((set == 0) || (m_barSets.contains(set))) {
675 675 // Fail if any of the sets is null or is already appended.
676 676 return false;
677 677 }
678 678 if (sets.count(set) != 1) {
679 679 // Also fail if same set is more than once in given list.
680 680 return false;
681 681 }
682 682 }
683 683
684 684 foreach (QBarSet* set, sets) {
685 685 m_barSets.append(set);
686 686 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
687 687 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
688 688 }
689 689 emit restructuredBars(); // this notifies barchartitem
690 690 if (m_dataset) {
691 691 m_dataset->updateSeries(q); // this notifies legend
692 692 }
693 693 return true;
694 694 }
695 695
696 696 bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
697 697 {
698 698 Q_Q(QAbstractBarSeries);
699 699 if (sets.count() == 0) {
700 700 return false;
701 701 }
702 702 foreach (QBarSet* set, sets) {
703 703 if ((set == 0) || (!m_barSets.contains(set))) {
704 704 // Fail if any of the sets is null or is not in series
705 705 return false;
706 706 }
707 707 if (sets.count(set) != 1) {
708 708 // Also fail if same set is more than once in given list.
709 709 return false;
710 710 }
711 711 }
712 712
713 713 foreach (QBarSet* set, sets) {
714 714 m_barSets.removeOne(set);
715 715 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
716 716 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
717 717 }
718 718
719 719 emit restructuredBars(); // this notifies barchartitem
720 720 if (m_dataset) {
721 721 m_dataset->updateSeries(q); // this notifies legend
722 722 }
723 723 return true;
724 724 }
725 725
726 726 bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
727 727 {
728 728 Q_Q(QAbstractBarSeries);
729 729 if ((m_barSets.contains(set)) || (set == 0)) {
730 730 // Fail if set is already in list or set is null.
731 731 return false;
732 732 }
733 733 m_barSets.insert(index, set);
734 734 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
735 735 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
736 736 emit restructuredBars(); // this notifies barchartitem
737 737 if (m_dataset) {
738 738 m_dataset->updateSeries(q); // this notifies legend
739 739 }
740 740 return true;
741 741 }
742 742
743 743 void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis)
744 744 {
745 745 Q_Q(QAbstractBarSeries);
746 746
747 747 if(axis->type()==QAbstractAxis::AxisTypeCategories) {
748 748
749 749 switch(q->type()) {
750 750
751 751 case QAbstractSeries::SeriesTypeHorizontalBar:
752 752 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
753 753 case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
754 754
755 755 if(axis->orientation()==Qt::Vertical)
756 756 {
757 populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
757 populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
758 758 }
759 759 break;
760 760 }
761 761 case QAbstractSeries::SeriesTypeBar:
762 762 case QAbstractSeries::SeriesTypePercentBar:
763 763 case QAbstractSeries::SeriesTypeStackedBar: {
764 764
765 765 if(axis->orientation()==Qt::Horizontal)
766 766 {
767 populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
767 populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
768 768 }
769 769 break;
770 770 }
771 771 default:
772 772 qWarning()<<"Unexpected series type";
773 773 break;
774 774
775 775 }
776 776 }
777 777 }
778 778
779 779 QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
780 780 {
781 781 Q_Q(const QAbstractBarSeries);
782 782
783 783 switch(q->type()) {
784 784
785 785 case QAbstractSeries::SeriesTypeHorizontalBar:
786 786 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
787 787 case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
788 788
789 789 if(orientation==Qt::Vertical)
790 790 {
791 791 return QAbstractAxis::AxisTypeCategories;
792 792 }
793 793 break;
794 794 }
795 795 case QAbstractSeries::SeriesTypeBar:
796 796 case QAbstractSeries::SeriesTypePercentBar:
797 797 case QAbstractSeries::SeriesTypeStackedBar: {
798 798
799 799 if(orientation==Qt::Horizontal)
800 800 {
801 801 return QAbstractAxis::AxisTypeCategories;
802 802 }
803 803 break;
804 804 }
805 805 default:
806 806 qWarning()<<"Unexpected series type";
807 807 break;
808 808
809 809 }
810 810 return QAbstractAxis::AxisTypeValues;
811 811
812 812 }
813 813
814 void QAbstractBarSeriesPrivate::populateCategories(QBarCategoriesAxis* axis)
814 void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis* axis)
815 815 {
816 816 QStringList categories;
817 817 if(axis->categories().isEmpty()) {
818 818 for (int i(1); i < categoryCount()+1; i++)
819 819 categories << QString::number(i);
820 820 axis->append(categories);
821 821 }
822 822 }
823 823
824 824 #include "moc_qabstractbarseries.cpp"
825 825 #include "moc_qabstractbarseries_p.cpp"
826 826
827 827
828 828 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,105 +1,105
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef QABSTRACTBARSERIES_P_H
31 31 #define QABSTRACTBARSERIES_P_H
32 32
33 33 #include "qabstractbarseries.h"
34 34 #include "qabstractseries_p.h"
35 35 #include <QStringList>
36 36 #include <QAbstractSeries>
37 37
38 38 QTCOMMERCIALCHART_BEGIN_NAMESPACE
39 39
40 40 class QBarModelMapper;
41 class QBarCategoriesAxis;
41 class QBarCategoryAxis;
42 42
43 43 class QAbstractBarSeriesPrivate : public QAbstractSeriesPrivate
44 44 {
45 45 Q_OBJECT
46 46 public:
47 47 QAbstractBarSeriesPrivate(QAbstractBarSeries *parent);
48 48 int categoryCount() const;
49 49
50 50 void setBarWidth(qreal width);
51 51 qreal barWidth() const;
52 52
53 53 void setVisible(bool visible);
54 54 void setLabelsVisible(bool visible);
55 55 void setGrouping(bool grouping);
56 56
57 57 void scaleDomain(Domain& domain);
58 58 ChartElement* createGraphics(ChartPresenter* presenter);
59 59 QList<LegendMarker*> createLegendMarker(QLegend* legend);
60 60
61 61 void initializeAxis(QAbstractAxis* axis);
62 62 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
63 63
64 64 bool append(QBarSet *set);
65 65 bool remove(QBarSet *set);
66 66 bool append(QList<QBarSet* > sets);
67 67 bool remove(QList<QBarSet* > sets);
68 68 bool insert(int index, QBarSet *set);
69 69
70 70 QBarSet* barsetAt(int index);
71 71 qreal min();
72 72 qreal max();
73 73 qreal valueAt(int set, int category);
74 74 qreal percentageAt(int set, int category);
75 75 qreal categorySum(int category);
76 76 qreal absoluteCategorySum(int category);
77 77 qreal maxCategorySum();
78 78 qreal minX();
79 79 qreal maxX();
80 80
81 81 Q_SIGNALS:
82 82 void clicked(int index, QBarSet *barset);
83 83 void updatedBars();
84 84 void restructuredBars();
85 85 void labelsVisibleChanged(bool visible);
86 86
87 87 private:
88 void populateCategories(QBarCategoriesAxis* axis);
88 void populateCategories(QBarCategoryAxis* axis);
89 89
90 90 protected:
91 91 QList<QBarSet *> m_barSets;
92 92 qreal m_barWidth;
93 93 bool m_labelsVisible;
94 94 bool m_visible;
95 95 bool m_grouping;
96 96
97 97 private:
98 98 Q_DECLARE_PUBLIC(QAbstractBarSeries)
99 99 friend class HorizontalBarChartItem;
100 100 friend class BarChartItem;
101 101 };
102 102
103 103 QTCOMMERCIALCHART_END_NAMESPACE
104 104
105 105 #endif // QABSTRACTBARSERIES_P_H
Show file before | Show file after | Hide comments
@@ -1,484 +1,484
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "chartdataset_p.h"
22 22 #include "qchart.h"
23 23 #include "qvalueaxis.h"
24 24 #include "qbarcategoriesaxis.h"
25 25 #include "qvalueaxis_p.h"
26 26 #include "qintervalsaxis.h"
27 27 #include "qdatetimeaxis.h"
28 28 #include "qabstractseries_p.h"
29 29 #include "qabstractbarseries.h"
30 30 #include "qstackedbarseries.h"
31 31 #include "qpercentbarseries.h"
32 32 #include "qpieseries.h"
33 33
34 34 QTCOMMERCIALCHART_BEGIN_NAMESPACE
35 35
36 36 ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
37 37 {
38 38
39 39 }
40 40
41 41 ChartDataSet::~ChartDataSet()
42 42 {
43 43 removeAllSeries();
44 44 }
45 45
46 46 void ChartDataSet::addSeries(QAbstractSeries* series)
47 47 {
48 48 Domain* domain = m_seriesDomainMap.value(series);
49 49
50 50 if(domain) {
51 51 qWarning() << "Can not add series. Series already on the chart";
52 52 return;
53 53 }
54 54
55 55 domain = new Domain(series);
56 56 m_seriesDomainMap.insert(series,domain);
57 57 series->d_ptr->scaleDomain(*domain);
58 58
59 59 createSeriesIndex(series);
60 60
61 61 series->setParent(this); // take ownership
62 62 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
63 63 series->d_ptr->m_dataset = this;
64 64
65 65 emit seriesAdded(series,domain);
66 66
67 67 }
68 68
69 69 void ChartDataSet::removeSeries(QAbstractSeries* series)
70 70 {
71 71
72 72 if(!m_seriesDomainMap.contains(series)) {
73 73 qWarning()<<"Can not remove series. Series not found on the chart.";
74 74 return;
75 75 }
76 76
77 77 emit seriesRemoved(series);
78 78
79 79 Domain* domain = m_seriesDomainMap.take(series);
80 80 delete domain;
81 81 domain = 0;
82 82
83 83 removeSeriesIndex(series);
84 84
85 85 series->setParent(0);
86 86 series->d_ptr->m_chart = 0;
87 87 series->d_ptr->m_dataset = 0;
88 88
89 89 removeAxes(series);
90 90 }
91 91
92 92
93 93
94 94 void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
95 95 {
96 96 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
97 97
98 98 int key=0;
99 99 while (i.hasNext()) {
100 100 i.next();
101 101 if(i.key()!=key) {
102 102 break;
103 103 }
104 104 key++;
105 105 }
106 106
107 107 m_indexSeriesMap.insert(key,series);
108 108 }
109 109
110 110 void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
111 111 {
112 112 int key = seriesIndex(series);
113 113 Q_ASSERT(key!=-1);
114 114 m_indexSeriesMap.remove(key);
115 115 }
116 116
117 117 void ChartDataSet::createDefaultAxes()
118 118 {
119 119
120 120 if(m_seriesDomainMap.isEmpty()) return;
121 121
122 122 QAbstractAxis::AxisTypes typeX(0);
123 123 QAbstractAxis::AxisTypes typeY(0);
124 124
125 125 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
126 126 while (i.hasNext()) {
127 127 i.next();
128 128 removeAxes(i.key());
129 129 }
130 130
131 131 i.toFront();
132 132
133 133 while (i.hasNext()) {
134 134 i.next();
135 135 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
136 136 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
137 137 if(axisX) typeX&=axisX->type();
138 138 else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
139 139 if(axisY) typeY&=axisY->type();
140 140 else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
141 141 }
142 142
143 143 createAxes(typeX,Qt::Horizontal);
144 144 createAxes(typeY,Qt::Vertical);
145 145 }
146 146
147 147 void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation)
148 148 {
149 149 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
150 150
151 151 if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories))
152 152 {
153 153 while (i.hasNext()) {
154 154 i.next();
155 155 QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation);
156 156 if(!axis) continue;
157 157 initializeAxis(axis,i.key());
158 158 emit axisAdded(axis,i.value());
159 159 }
160 160
161 161 }
162 162 else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
163 163 QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation);
164 164 i.toFront();
165 165 while (i.hasNext()) {
166 166 i.next();
167 167 initializeAxis(axis,i.key());
168 168 }
169 169 emit axisAdded(axis,i.value());
170 170 }
171 171 }
172 172
173 173
174 174 QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation)
175 175 {
176 176 QAbstractAxis* axis =0;
177 177
178 178 switch(type) {
179 179 case QAbstractAxis::AxisTypeValues:
180 180 axis = new QValueAxis(this);
181 181 break;
182 182 case QAbstractAxis::AxisTypeCategories:
183 axis = new QBarCategoriesAxis(this);
183 axis = new QBarCategoryAxis(this);
184 184 break;
185 185 case QAbstractAxis::AxisTypeIntervals:
186 186 axis = new QIntervalsAxis(this);
187 187 break;
188 188 case QAbstractAxis::AxisTypeDateTime:
189 189 axis = new QDateTimeAxis(this);
190 190 break;
191 191 default:
192 192 axis = 0;
193 193 break;
194 194 }
195 195
196 196 if(axis)
197 197 axis->d_ptr->setOrientation(orientation);
198 198
199 199 return axis;
200 200 }
201 201
202 202 void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
203 203 {
204 204 Domain* domain = m_seriesDomainMap.value(series);
205 205 axis->d_ptr->m_dataset = this;
206 206 series->d_ptr->initializeAxis(axis);
207 207 axis->d_ptr->intializeDomain(domain);
208 208 if(axis->orientation()==Qt::Horizontal) {
209 209 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
210 210 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
211 211 m_seriesAxisXMap.insert(series,axis);
212 212 }
213 213 else {
214 214 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
215 215 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
216 216 m_seriesAxisYMap.insert(series,axis);
217 217 }
218 218 axis->d_ptr->emitUpdated();
219 219 }
220 220
221 221 void ChartDataSet::removeAxes(QAbstractSeries* series)
222 222 {
223 223 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
224 224
225 225 if(axisX) {
226 226 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
227 227 int x = axesX.indexOf(axisX);
228 228
229 229 if(x==-1) {
230 230 emit axisRemoved(axisX);
231 231 axisX->d_ptr->m_dataset=0;
232 232 axisX->deleteLater();
233 233 }
234 234 }
235 235
236 236 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
237 237
238 238 if(axisY) {
239 239 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
240 240
241 241 int y = axesY.indexOf(axisY);
242 242
243 243 if(y==-1) {
244 244 emit axisRemoved(axisY);
245 245 axisY->d_ptr->m_dataset=0;
246 246 axisY->deleteLater();
247 247 }
248 248 }
249 249 }
250 250
251 251 void ChartDataSet::removeAxis(QAbstractAxis* axis)
252 252 {
253 253 if(!axis->d_ptr->m_dataset) {
254 254 qWarning()<<"UnBound axis found !";
255 255 return;
256 256 }
257 257
258 258 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
259 259
260 260 if(axis->orientation()==Qt::Vertical) {
261 261 seriesAxisMap= &m_seriesAxisYMap;
262 262 }
263 263 else {
264 264 seriesAxisMap= &m_seriesAxisXMap;
265 265 }
266 266
267 267 QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
268 268
269 269 while (i.hasNext()) {
270 270 i.next();
271 271 if(i.value()==axis) {
272 272 removeSeries(i.key());
273 273 }
274 274 }
275 275 }
276 276
277 277 void ChartDataSet::removeAllSeries()
278 278 {
279 279 QList<QAbstractSeries*> series = m_seriesDomainMap.keys();
280 280 foreach(QAbstractSeries *s , series) {
281 281 removeSeries(s);
282 282 }
283 283
284 284 Q_ASSERT(m_seriesAxisXMap.count()==0);
285 285 Q_ASSERT(m_seriesAxisXMap.count()==0);
286 286 Q_ASSERT(m_seriesDomainMap.count()==0);
287 287
288 288 qDeleteAll(series);
289 289 }
290 290
291 291 void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
292 292 {
293 293 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
294 294
295 295
296 296 blockAxisSignals(true);
297 297
298 298 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
299 299
300 300 while (i.hasNext()) {
301 301 i.next();
302 302 i.value()->zoomIn(rect,size);
303 303 }
304 304
305 305 blockAxisSignals(false);
306 306
307 307 }
308 308
309 309 void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
310 310 {
311 311 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
312 312
313 313 blockAxisSignals(true);
314 314
315 315 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
316 316
317 317 while (i.hasNext()) {
318 318 i.next();
319 319 i.value()->zoomOut(rect,size);
320 320 }
321 321
322 322 blockAxisSignals(false);
323 323 }
324 324
325 325 void ChartDataSet::blockAxisSignals(bool enabled)
326 326 {
327 327 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
328 328 while (i.hasNext()) {
329 329 i.next();
330 330 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
331 331 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
332 332 if(axisX) {
333 333 axisX->d_ptr->blockSignals(enabled);
334 334 if(!enabled) {
335 335 axisX->d_ptr->setDirty(false);
336 336 axisX->d_ptr->emitUpdated();
337 337 }
338 338 }
339 339 if(axisY) {
340 340 axisY->d_ptr->blockSignals(enabled);
341 341 if(!enabled) {
342 342 axisY->d_ptr->setDirty(false);
343 343 axisY->d_ptr->emitUpdated();
344 344 }
345 345 }
346 346 }
347 347 }
348 348
349 349 int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
350 350 {
351 351 int count=0;
352 352 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
353 353 while (i.hasNext()) {
354 354 i.next();
355 355 if(i.key()->type()==type) count++;
356 356 }
357 357 return count;
358 358 }
359 359
360 360 int ChartDataSet::seriesIndex(QAbstractSeries *series)
361 361 {
362 362 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
363 363 while (i.hasNext()) {
364 364 i.next();
365 365 if (i.value() == series)
366 366 return i.key();
367 367 }
368 368 return -1;
369 369 }
370 370
371 371 QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
372 372 {
373 373 if(series == 0) {
374 374
375 375 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
376 376
377 377 while (i.hasNext()) {
378 378 i.next();
379 379 if(i.value()->isVisible()) return i.value();
380 380 }
381 381 return 0;
382 382 }
383 383 return m_seriesAxisXMap.value(series);
384 384 }
385 385
386 386 QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
387 387 {
388 388 if(series == 0) {
389 389 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
390 390
391 391 while (i.hasNext()) {
392 392 i.next();
393 393 if(i.value()->isVisible()) return i.value();
394 394 }
395 395 return 0;
396 396 }
397 397 return m_seriesAxisYMap.value(series);
398 398 }
399 399
400 400 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
401 401 {
402 402 Q_ASSERT(axis);
403 403
404 404 if(!series) {
405 405 qWarning() << "Series not found on the chart.";
406 406 return;
407 407 }
408 408
409 409 Domain* domain = m_seriesDomainMap.value(series);
410 410
411 411 if(!domain) {
412 412 qWarning() << "Series not found on the chart.";
413 413 return;
414 414 }
415 415
416 416 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
417 417 qWarning()<<"Axis already defined as axis Y";
418 418 return;
419 419 }
420 420
421 421 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
422 422 qWarning()<<"Axis already defined as axis X";
423 423 return;
424 424 }
425 425
426 426 axis->d_ptr->setOrientation(orientation);
427 427
428 428 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
429 429
430 430 if(orientation==Qt::Vertical) {
431 431 seriesAxisMap= &m_seriesAxisYMap;
432 432 }else{
433 433 seriesAxisMap= &m_seriesAxisXMap;
434 434 }
435 435
436 436 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
437 437 QList<QAbstractAxis*> axes = seriesAxisMap->values();
438 438 if(oldAxis) {
439 439 if(axes.indexOf(oldAxis)==-1) {
440 440 emit axisRemoved(oldAxis);
441 441 oldAxis->disconnect();
442 442 QObject::disconnect(domain,0,oldAxis,0);
443 443 oldAxis->d_ptr->m_dataset=0;
444 444 oldAxis->deleteLater();
445 445 }
446 446 }
447 447
448 448 if(axes.indexOf(axis)==-1) {
449 449 initializeAxis(axis,series);
450 450 emit axisAdded(axis,domain);
451 451 }else{
452 452 initializeAxis(axis,series);
453 453 }
454 454 }
455 455
456 456 Domain* ChartDataSet::domain(QAbstractSeries *series) const
457 457 {
458 458 return m_seriesDomainMap.value(series);
459 459 }
460 460
461 461 void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
462 462 {
463 463 blockAxisSignals(true);
464 464 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
465 465 while (i.hasNext()) {
466 466 i.next();
467 467 i.value()->move(dx,dy,size);
468 468 }
469 469 blockAxisSignals(false);
470 470 }
471 471
472 472 QList<QAbstractSeries*> ChartDataSet::series() const
473 473 {
474 474 return m_seriesDomainMap.keys();
475 475 }
476 476
477 477 void ChartDataSet::updateSeries(QAbstractSeries *series)
478 478 {
479 479 emit seriesUpdated(series);
480 480 }
481 481
482 482 #include "moc_chartdataset_p.cpp"
483 483
484 484 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,649 +1,649
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "../qabstractaxis/tst_qabstractaxis.h"
22 22 #include <qbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qbarcategoriesaxis.h>
25 25
26 26 class tst_QBarCategoriesAxis: public tst_QAbstractAxis
27 27 {
28 28 Q_OBJECT
29 29
30 30 public slots:
31 31 void initTestCase();
32 32 void cleanupTestCase();
33 33 void init();
34 34 void cleanup();
35 35
36 36 private slots:
37 37 void qbarcategoriesaxis_data();
38 38 void qbarcategoriesaxis();
39 39
40 40 void append_data();
41 41 void append();
42 42 void at_data();
43 43 void at();
44 44 void categories_data();
45 45 void categories();
46 46 void clear_data();
47 47 void clear();
48 48 void count_data();
49 49 void count();
50 50 void insert_data();
51 51 void insert();
52 52 void remove_data();
53 53 void remove();
54 54 void max_raw_data();
55 55 void max_raw();
56 56 void max_data();
57 57 void max();
58 58 void max_animation_data();
59 59 void max_animation();
60 60 void min_raw_data();
61 61 void min_raw();
62 62 void min_data();
63 63 void min();
64 64 void min_animation_data();
65 65 void min_animation();
66 66 void range_raw_data();
67 67 void range_raw();
68 68 void range_data();
69 69 void range();
70 70 void range_animation_data();
71 71 void range_animation();
72 72 void noautoscale_data();
73 73 void noautoscale();
74 74 void autoscale_data();
75 75 void autoscale();
76 76
77 77 private:
78 QBarCategoriesAxis* m_baraxis;
78 QBarCategoryAxis* m_baraxis;
79 79 QBarSeries* m_series;
80 80 };
81 81
82 82 void tst_QBarCategoriesAxis::initTestCase()
83 83 {
84 84 }
85 85
86 86 void tst_QBarCategoriesAxis::cleanupTestCase()
87 87 {
88 88 }
89 89
90 90 void tst_QBarCategoriesAxis::init()
91 91 {
92 m_baraxis = new QBarCategoriesAxis();
92 m_baraxis = new QBarCategoryAxis();
93 93 m_series = new QBarSeries();
94 94
95 95 QBarSet *set0 = new QBarSet("Jane");
96 96 QBarSet *set1 = new QBarSet("John");
97 97 QBarSet *set2 = new QBarSet("Axel");
98 98 QBarSet *set3 = new QBarSet("Mary");
99 99 QBarSet *set4 = new QBarSet("Samantha");
100 100
101 101 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
102 102 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
103 103 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
104 104 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
105 105 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
106 106
107 107 m_series->append(set0);
108 108 m_series->append(set1);
109 109 m_series->append(set2);
110 110 m_series->append(set3);
111 111 m_series->append(set4);
112 112
113 113 QStringList categories;
114 114 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
115 115
116 116 m_baraxis->append(categories);
117 117
118 118 tst_QAbstractAxis::init(m_baraxis, m_series);
119 119 m_chart->addSeries(m_series);
120 120 m_chart->createDefaultAxes();
121 121 }
122 122
123 123 void tst_QBarCategoriesAxis::cleanup()
124 124 {
125 125 delete m_series;
126 126 delete m_baraxis;
127 127 m_series = 0;
128 128 m_baraxis = 0;
129 129 tst_QAbstractAxis::cleanup();
130 130 }
131 131
132 132 void tst_QBarCategoriesAxis::qbarcategoriesaxis_data()
133 133 {
134 134 }
135 135
136 136 void tst_QBarCategoriesAxis::qbarcategoriesaxis()
137 137 {
138 138 qabstractaxis();
139 QBarCategoriesAxis axis;
139 QBarCategoryAxis axis;
140 140 axis.append(QStringList());
141 141 axis.append(QString());
142 142 QCOMPARE(axis.at(0), QString());
143 143 QStringList test;
144 144 test.append(QString());
145 145 QCOMPARE(axis.categories(),test);
146 146 axis.clear();
147 147 QCOMPARE(axis.count(), 0);
148 148 axis.insert(-1, QString());
149 149 QCOMPARE(axis.max(), QString());
150 150 QCOMPARE(axis.min(), QString());
151 151 axis.remove(QString());
152 152 axis.setCategories(QStringList());
153 153 axis.setMax(QString());
154 154 axis.setMin(QString());
155 155 axis.setRange(QString(), QString());
156 156 QCOMPARE(axis.type(), QAbstractAxis::AxisTypeCategories);
157 157 }
158 158
159 159 void tst_QBarCategoriesAxis::append_data()
160 160 {
161 161 QTest::addColumn<QStringList>("categories");
162 162 QTest::newRow("Jan Feb Mar Apr") << (QStringList() << "Jan" << "Feb" << "Mar" << "Apr");
163 163 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
164 164 }
165 165
166 166 void tst_QBarCategoriesAxis::append()
167 167 {
168 168 QFETCH(QStringList, categories);
169 169
170 QBarCategoriesAxis axis;
170 QBarCategoryAxis axis;
171 171
172 172 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
173 173 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
174 174 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
175 175 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
176 176
177 177 axis.append(categories);
178 178
179 179 QCOMPARE(spy0.count(), 1);
180 180 QCOMPARE(spy1.count(), 1);
181 181 QCOMPARE(spy2.count(), 1);
182 182 QCOMPARE(spy3.count(), 1);
183 183
184 184 m_chart->setAxisX(&axis, m_series);
185 185 m_view->show();
186 186 QTest::qWaitForWindowShown(m_view);
187 187 QCOMPARE(axis.categories(), categories);
188 188
189 189 QCOMPARE(spy0.count(), 1);
190 190 QCOMPARE(spy1.count(), 1);
191 191 QCOMPARE(spy2.count(), 1);
192 192 QCOMPARE(spy3.count(), 1);
193 193 }
194 194
195 195 void tst_QBarCategoriesAxis::at_data()
196 196 {
197 197 QTest::addColumn<QStringList>("categories");
198 198 QTest::addColumn<int>("index");
199 199 QTest::addColumn<QString>("string");
200 200 QTest::newRow("Jul Aug Sep 0 Jul") << (QStringList() << "Jul" << "Aug" << "Sep") << 0 << "Jul";
201 201 QTest::newRow("Jul Aug Sep 2 Sep") << (QStringList() << "Jul" << "Aug" << "Sep") << 2 << "Sep";
202 202 QTest::newRow("Jul Aug Sep 1 Aug") << (QStringList() << "Jul" << "Aug" << "Sep") << 1 << "Aug";
203 203 }
204 204
205 205 void tst_QBarCategoriesAxis::at()
206 206 {
207 207 QFETCH(int, index);
208 208 QFETCH(QString, string);
209 209 QFETCH(QStringList, categories);
210 210
211 QBarCategoriesAxis axis;
211 QBarCategoryAxis axis;
212 212 axis.append(categories);
213 213
214 214 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
215 215 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
216 216 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
217 217 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
218 218
219 219 QCOMPARE(axis.at(index), string);
220 220
221 221 QCOMPARE(spy0.count(), 0);
222 222 QCOMPARE(spy1.count(), 0);
223 223 QCOMPARE(spy2.count(), 0);
224 224 QCOMPARE(spy3.count(), 0);
225 225
226 226 m_chart->setAxisX(&axis, m_series);
227 227 m_view->show();
228 228 QTest::qWaitForWindowShown(m_view);
229 229 QCOMPARE(axis.at(index), string);
230 230
231 231 QCOMPARE(spy0.count(), 0);
232 232 QCOMPARE(spy1.count(), 0);
233 233 QCOMPARE(spy2.count(), 0);
234 234 QCOMPARE(spy3.count(), 0);
235 235 }
236 236
237 237 void tst_QBarCategoriesAxis::categories_data()
238 238 {
239 239 QTest::addColumn<QStringList>("categories");
240 240 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
241 241 }
242 242
243 243 void tst_QBarCategoriesAxis::categories()
244 244 {
245 245 QFETCH(QStringList, categories);
246 246
247 QBarCategoriesAxis axis;
247 QBarCategoryAxis axis;
248 248
249 249 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
250 250 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
251 251 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
252 252 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
253 253
254 254 axis.setCategories(categories);
255 255 QCOMPARE(axis.categories(), categories);
256 256
257 257 QCOMPARE(spy0.count(), 1);
258 258 QCOMPARE(spy1.count(), 1);
259 259 QCOMPARE(spy2.count(), 1);
260 260 QCOMPARE(spy3.count(), 1);
261 261
262 262 m_chart->setAxisX(&axis, m_series);
263 263 m_view->show();
264 264 QTest::qWaitForWindowShown(m_view);
265 265 QCOMPARE(axis.categories(), categories);
266 266
267 267 QCOMPARE(spy0.count(), 1);
268 268 QCOMPARE(spy1.count(), 1);
269 269 QCOMPARE(spy2.count(), 1);
270 270 QCOMPARE(spy3.count(), 1);
271 271
272 272 }
273 273
274 274 void tst_QBarCategoriesAxis::clear_data()
275 275 {
276 276 QTest::addColumn<QStringList>("categories");
277 277 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
278 278 }
279 279
280 280 void tst_QBarCategoriesAxis::clear()
281 281 {
282 282 QFETCH(QStringList, categories);
283 283
284 QBarCategoriesAxis axis;
284 QBarCategoryAxis axis;
285 285
286 286 axis.setCategories(categories);
287 287 QCOMPARE(axis.categories(), categories);
288 288
289 289 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
290 290 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
291 291 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
292 292 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
293 293
294 294 axis.clear();
295 295 QCOMPARE(axis.categories(), QStringList());
296 296
297 297 QCOMPARE(spy0.count(), 1);
298 298 QCOMPARE(spy1.count(), 1);
299 299 QCOMPARE(spy2.count(), 1);
300 300 QCOMPARE(spy3.count(), 1);
301 301
302 302 m_chart->setAxisX(&axis, m_series);
303 303 m_view->show();
304 304 QTest::qWaitForWindowShown(m_view);
305 305
306 306 QCOMPARE(spy0.count(), 2);
307 307 QCOMPARE(spy1.count(), 2);
308 308 QCOMPARE(spy2.count(), 2);
309 309 QCOMPARE(spy3.count(), 2);
310 310
311 311 axis.clear();
312 312 QCOMPARE(axis.categories().count(),0);
313 313 QCOMPARE(spy0.count(), 3);
314 314 QCOMPARE(spy1.count(), 3);
315 315 QCOMPARE(spy2.count(), 3);
316 316 QCOMPARE(spy3.count(), 3);
317 317 }
318 318
319 319 void tst_QBarCategoriesAxis::count_data()
320 320 {
321 321 QTest::addColumn<QStringList>("categories");
322 322 QTest::addColumn<int>("count");
323 323 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep") << 3;
324 324 QTest::newRow("Jul Aug ") << (QStringList() << "Jul" << "Aug") << 2;
325 325 }
326 326
327 327 void tst_QBarCategoriesAxis::count()
328 328 {
329 329 QFETCH(QStringList, categories);
330 330 QFETCH(int, count);
331 331
332 QBarCategoriesAxis axis;
332 QBarCategoryAxis axis;
333 333 axis.setCategories(categories);
334 334
335 335 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
336 336 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
337 337 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
338 338 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
339 339
340 340 QCOMPARE(axis.count(), count);
341 341
342 342 QCOMPARE(spy0.count(), 0);
343 343 QCOMPARE(spy1.count(), 0);
344 344 QCOMPARE(spy2.count(), 0);
345 345 QCOMPARE(spy3.count(), 0);
346 346
347 347 m_chart->setAxisX(&axis, m_series);
348 348 m_view->show();
349 349 QTest::qWaitForWindowShown(m_view);
350 350 QCOMPARE(axis.count(), count);
351 351 }
352 352
353 353 void tst_QBarCategoriesAxis::insert_data()
354 354 {
355 355 QTest::addColumn<QStringList>("categories");
356 356 QTest::addColumn<int>("index");
357 357 QTest::addColumn<QString>("category");
358 358 QTest::newRow("Jul Aug Sep 0 Jun") << (QStringList() << "Jul" << "Aug" << "Sep") << 0 << "Jun";
359 359 QTest::newRow("Jul Aug Sep 3 Sep") << (QStringList() << "Jul" << "Aug" << "Sep") << 3 << "Sep";
360 360 QTest::newRow("Jul Aug Sep 2 Summer") << (QStringList() << "Jul" << "Aug" << "Sep") << 2 << "Summer";
361 361 }
362 362
363 363 void tst_QBarCategoriesAxis::insert()
364 364 {
365 365 QFETCH(QStringList, categories);
366 366 QFETCH(int, index);
367 367 QFETCH(QString, category);
368 368
369 QBarCategoriesAxis axis;
369 QBarCategoryAxis axis;
370 370 axis.append(categories);
371 371
372 372 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
373 373 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
374 374 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
375 375 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
376 376
377 377 axis.insert(index, category);
378 378 QCOMPARE(axis.at(index),category);
379 379
380 380 QCOMPARE(spy0.count(), 1);
381 381 QCOMPARE(spy1.count(), 0);
382 382 QCOMPARE(spy2.count(), 0);
383 383 QCOMPARE(spy3.count(), 0);
384 384
385 385 m_chart->setAxisX(&axis, m_series);
386 386 m_view->show();
387 387 QTest::qWaitForWindowShown(m_view);
388 388 }
389 389
390 390 void tst_QBarCategoriesAxis::remove_data()
391 391 {
392 392 QTest::addColumn<QStringList>("categories");
393 393 QTest::addColumn<QString>("category");
394 394 QTest::addColumn<QStringList>("result");
395 395 QTest::newRow("Jul Aug Sep 0") << (QStringList() << "Jul" << "Aug" << "Sep") << "Jul" << (QStringList() << "Aug" << "Sep");
396 396 QTest::newRow("Jul Aug Sep 1") << (QStringList() << "Jul" << "Aug" << "Sep") << "Aug"<< (QStringList() << "Jul" << "Sep");
397 397 }
398 398
399 399 void tst_QBarCategoriesAxis::remove()
400 400 {
401 401 QFETCH(QStringList, categories);
402 402 QFETCH(QString, category);
403 403 QFETCH(QStringList, result);
404 404
405 QBarCategoriesAxis axis;
405 QBarCategoryAxis axis;
406 406 axis.append(categories);
407 407
408 408 int maxCount = axis.max() == category;
409 409 int minCount = axis.min() == category;
410 410 int rangeCount = maxCount + minCount;
411 411
412 412 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
413 413 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
414 414 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
415 415 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
416 416
417 417 axis.remove(category);
418 418 QCOMPARE(axis.categories(),result);
419 419
420 420 QCOMPARE(spy0.count(), 1);
421 421 QCOMPARE(spy1.count(), maxCount);
422 422 QCOMPARE(spy2.count(), minCount);
423 423 QCOMPARE(spy3.count(), rangeCount);
424 424 }
425 425
426 426 void tst_QBarCategoriesAxis::max_raw_data()
427 427 {
428 428 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
429 429 QTest::addColumn<QString>("max");
430 430 QTest::newRow("Feb") << "Feb";
431 431 QTest::newRow("Apr") << "Apr";
432 432 QTest::newRow("May") << "May";
433 433 }
434 434
435 435 void tst_QBarCategoriesAxis::max_raw()
436 436 {
437 437 QFETCH(QString, max);
438 438
439 439 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
440 440 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
441 441 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
442 442 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
443 443
444 444 m_baraxis->setMax(max);
445 445 QCOMPARE(m_baraxis->max(), max);
446 446
447 447 QCOMPARE(spy0.count(), 0);
448 448 QCOMPARE(spy1.count(), 1);
449 449 QCOMPARE(spy2.count(), 0);
450 450 QCOMPARE(spy3.count(), 1);
451 451 }
452 452
453 453 void tst_QBarCategoriesAxis::max_data()
454 454 {
455 455 max_raw_data();
456 456 }
457 457
458 458 void tst_QBarCategoriesAxis::max()
459 459 {
460 460 m_chart->setAxisX(m_baraxis, m_series);
461 461 m_view->show();
462 462 QTest::qWaitForWindowShown(m_view);
463 463 max_raw();
464 464 }
465 465
466 466 void tst_QBarCategoriesAxis::max_animation_data()
467 467 {
468 468 max_data();
469 469 }
470 470
471 471 void tst_QBarCategoriesAxis::max_animation()
472 472 {
473 473 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
474 474 max();
475 475 }
476 476
477 477 void tst_QBarCategoriesAxis::min_raw_data()
478 478 {
479 479 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
480 480 QTest::addColumn<QString>("min");
481 481 QTest::newRow("Feb") << "Feb";
482 482 QTest::newRow("Apr") << "Apr";
483 483 QTest::newRow("May") << "May";
484 484 }
485 485
486 486 void tst_QBarCategoriesAxis::min_raw()
487 487 {
488 488 QFETCH(QString, min);
489 489
490 490 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
491 491 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
492 492 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
493 493 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
494 494
495 495 m_baraxis->setMin(min);
496 496 QCOMPARE(m_baraxis->min(), min);
497 497
498 498 QCOMPARE(spy0.count(), 0);
499 499 QCOMPARE(spy1.count(), 0);
500 500 QCOMPARE(spy2.count(), 1);
501 501 QCOMPARE(spy3.count(), 1);
502 502
503 503 }
504 504
505 505 void tst_QBarCategoriesAxis::min_data()
506 506 {
507 507 min_raw_data();
508 508 }
509 509
510 510 void tst_QBarCategoriesAxis::min()
511 511 {
512 512 m_chart->setAxisX(m_baraxis, m_series);
513 513 m_view->show();
514 514 QTest::qWaitForWindowShown(m_view);
515 515 min_raw();
516 516 }
517 517
518 518 void tst_QBarCategoriesAxis::min_animation_data()
519 519 {
520 520 min_data();
521 521 }
522 522
523 523 void tst_QBarCategoriesAxis::min_animation()
524 524 {
525 525 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
526 526 min();
527 527 }
528 528
529 529
530 530 void tst_QBarCategoriesAxis::range_raw_data()
531 531 {
532 532 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
533 533 QTest::addColumn<QString>("min");
534 534 QTest::addColumn<QString>("max");
535 535 QTest::newRow("Feb - Apr") << "Feb" << "Apr";
536 536 QTest::newRow("Feb - May") << "Feb" << "May";
537 537 QTest::newRow("Mar - Apr") << "Mar" << "Apr";
538 538 }
539 539
540 540 void tst_QBarCategoriesAxis::range_raw()
541 541 {
542 542 QFETCH(QString, min);
543 543 QFETCH(QString, max);
544 544
545 545 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
546 546 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
547 547 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
548 548 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
549 549
550 550 m_baraxis->setRange(min, max);
551 551 QCOMPARE(m_baraxis->min(), min);
552 552 QCOMPARE(m_baraxis->max(), max);
553 553
554 554 QCOMPARE(spy0.count(), 0);
555 555 QCOMPARE(spy1.count(), 1);
556 556 QCOMPARE(spy2.count(), 1);
557 557 QCOMPARE(spy3.count(), 1);
558 558 }
559 559
560 560 void tst_QBarCategoriesAxis::range_data()
561 561 {
562 562 range_raw_data();
563 563 }
564 564
565 565 void tst_QBarCategoriesAxis::range()
566 566 {
567 567 m_chart->setAxisX(m_baraxis, m_series);
568 568 m_view->show();
569 569 QTest::qWaitForWindowShown(m_view);
570 570 range_raw();
571 571 }
572 572
573 573 void tst_QBarCategoriesAxis::range_animation_data()
574 574 {
575 575 range_data();
576 576 }
577 577
578 578 void tst_QBarCategoriesAxis::range_animation()
579 579 {
580 580 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
581 581 range();
582 582 }
583 583
584 584
585 585 void tst_QBarCategoriesAxis::noautoscale_data()
586 586 {
587 587 QTest::addColumn<QString>("min");
588 588 QTest::addColumn<QString>("max");
589 589 QTest::newRow("Feb - Mar") << "Feb" << "Mar";
590 590 QTest::newRow("Feb - May") << "Feb" << "May";
591 591 QTest::newRow("Apr - May") << "Apr" << "May";
592 592 }
593 593
594 594 void tst_QBarCategoriesAxis::noautoscale()
595 595 {
596 596 QFETCH(QString, min);
597 597 QFETCH(QString, max);
598 598
599 599 QSignalSpy spy0(m_baraxis, SIGNAL(maxChanged(QString)));
600 600 QSignalSpy spy1(m_baraxis, SIGNAL(minChanged(QString)));
601 601 QSignalSpy spy2(m_baraxis, SIGNAL(rangeChanged(QString, QString)));
602 602
603 603 m_baraxis->setRange(min, max);
604 604 QCOMPARE(m_baraxis->min(),min);
605 605 QCOMPARE(m_baraxis->max(),max);
606 606
607 607 QCOMPARE(spy0.count(), 1);
608 608 QCOMPARE(spy1.count(), 1);
609 609 QCOMPARE(spy2.count(), 1);
610 610
611 611 m_chart->setAxisX(m_baraxis, m_series);
612 612 m_view->show();
613 613 QTest::qWaitForWindowShown(m_view);
614 614 QCOMPARE(m_baraxis->min(),min);
615 615 QCOMPARE(m_baraxis->max(),max);
616 616 }
617 617
618 618 void tst_QBarCategoriesAxis::autoscale_data()
619 619 {
620 620
621 621 }
622 622
623 623 void tst_QBarCategoriesAxis::autoscale()
624 624 {
625 625 delete m_baraxis;
626 m_baraxis = new QBarCategoriesAxis();
626 m_baraxis = new QBarCategoryAxis();
627 627
628 628 QSignalSpy spy0(m_baraxis, SIGNAL(maxChanged(QString)));
629 629 QSignalSpy spy1(m_baraxis, SIGNAL(minChanged(QString)));
630 630 QSignalSpy spy2(m_baraxis, SIGNAL(rangeChanged(QString, QString)));
631 631
632 632 QCOMPARE(m_baraxis->min(),QString());
633 633 QCOMPARE(m_baraxis->max(),QString());
634 634 m_chart->setAxisX(m_baraxis, m_series);
635 635
636 636 QCOMPARE(spy0.count(), 1);
637 637 QCOMPARE(spy1.count(), 1);
638 638 QCOMPARE(spy2.count(), 1);
639 639
640 640 m_view->show();
641 641 QTest::qWaitForWindowShown(m_view);
642 642 QCOMPARE(m_baraxis->min(),QString("1"));
643 643 QCOMPARE(m_baraxis->max(),QString("6"));
644 644 }
645 645
646 646
647 647 QTEST_MAIN(tst_QBarCategoriesAxis)
648 648 #include "tst_qbarcategoriesaxis.moc"
649 649
Show file before | Show file after | Hide comments
@@ -1,788 +1,788
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QtTest/QtTest>
22 22 #include <qchartview.h>
23 23 #include <qlineseries.h>
24 24 #include <qareaseries.h>
25 25 #include <qscatterseries.h>
26 26 #include <qsplineseries.h>
27 27 #include <qpieseries.h>
28 28 #include <qabstractbarseries.h>
29 29 #include <qbarseries.h>
30 30 #include <qpercentbarseries.h>
31 31 #include <qstackedbarseries.h>
32 32 #include <qvalueaxis.h>
33 33 #include <qbarcategoriesaxis.h>
34 34
35 35 QTCOMMERCIALCHART_USE_NAMESPACE
36 36
37 37 Q_DECLARE_METATYPE(QAbstractAxis *)
38 38 Q_DECLARE_METATYPE(QValueAxis *)
39 Q_DECLARE_METATYPE(QBarCategoriesAxis *)
39 Q_DECLARE_METATYPE(QBarCategoryAxis *)
40 40 Q_DECLARE_METATYPE(QAbstractSeries *)
41 41 Q_DECLARE_METATYPE(QChart::AnimationOption)
42 42 Q_DECLARE_METATYPE(QBrush)
43 43 Q_DECLARE_METATYPE(QPen)
44 44 Q_DECLARE_METATYPE(QChart::ChartTheme)
45 45
46 46 class tst_QChart : public QObject
47 47 {
48 48 Q_OBJECT
49 49
50 50 public slots:
51 51 void initTestCase();
52 52 void cleanupTestCase();
53 53 void init();
54 54 void cleanup();
55 55
56 56 private slots:
57 57 void qchart_data();
58 58 void qchart();
59 59 void addSeries_data();
60 60 void addSeries();
61 61 void animationOptions_data();
62 62 void animationOptions();
63 63 void axisX_data();
64 64 void axisX();
65 65 void axisY_data();
66 66 void axisY();
67 67 void backgroundBrush_data();
68 68 void backgroundBrush();
69 69 void backgroundPen_data();
70 70 void backgroundPen();
71 71 void isBackgroundVisible_data();
72 72 void isBackgroundVisible();
73 73 void legend_data();
74 74 void legend();
75 75 void margins_data();
76 76 void margins();
77 77 void removeAllSeries_data();
78 78 void removeAllSeries();
79 79 void removeSeries_data();
80 80 void removeSeries();
81 81 void scroll_right_data();
82 82 void scroll_right();
83 83 void scroll_left_data();
84 84 void scroll_left();
85 85 void scroll_up_data();
86 86 void scroll_up();
87 87 void scroll_down_data();
88 88 void scroll_down();
89 89 void theme_data();
90 90 void theme();
91 91 void title_data();
92 92 void title();
93 93 void titleBrush_data();
94 94 void titleBrush();
95 95 void titleFont_data();
96 96 void titleFont();
97 97 void zoomIn_data();
98 98 void zoomIn();
99 99 void zoomOut_data();
100 100 void zoomOut();
101 101
102 102 private:
103 103 void createTestData();
104 104
105 105 private:
106 106 QChartView* m_view;
107 107 QChart* m_chart;
108 108 };
109 109
110 110 void tst_QChart::initTestCase()
111 111 {
112 112
113 113 }
114 114
115 115 void tst_QChart::cleanupTestCase()
116 116 {
117 117
118 118 }
119 119
120 120 void tst_QChart::init()
121 121 {
122 122 m_view = new QChartView(new QChart());
123 123 m_chart = m_view->chart();
124 124 }
125 125
126 126 void tst_QChart::cleanup()
127 127 {
128 128 delete m_view;
129 129 m_view = 0;
130 130 m_chart = 0;
131 131 }
132 132
133 133
134 134 void tst_QChart::createTestData()
135 135 {
136 136 QLineSeries* series0 = new QLineSeries(this);
137 137 *series0 << QPointF(0, 0) << QPointF(100, 100);
138 138 m_chart->addSeries(series0);
139 139 m_view->show();
140 140 QTest::qWaitForWindowShown(m_view);
141 141 }
142 142
143 143 void tst_QChart::qchart_data()
144 144 {
145 145 }
146 146
147 147 void tst_QChart::qchart()
148 148 {
149 149 QVERIFY(m_chart);
150 150 QVERIFY(m_chart->legend());
151 151 QVERIFY(m_chart->legend()->isVisible());
152 152
153 153 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
154 154 QVERIFY(!m_chart->axisX());
155 155 QVERIFY(!m_chart->axisY());
156 156 QVERIFY(m_chart->backgroundBrush()!=QBrush());
157 157 QVERIFY(m_chart->backgroundPen()!=QPen());
158 158 QCOMPARE(m_chart->isBackgroundVisible(), true);
159 159
160 160 QVERIFY(m_chart->margins().top()>0);
161 161 QVERIFY(m_chart->margins().left()>0);
162 162 QVERIFY(m_chart->margins().right()>0);
163 163 QVERIFY(m_chart->margins().bottom()>0);
164 164
165 165 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
166 166 QCOMPARE(m_chart->title(), QString());
167 167
168 168 //QCOMPARE(m_chart->titleBrush(),QBrush());
169 169 //QCOMPARE(m_chart->titleFont(),QFont());
170 170
171 171 m_chart->removeAllSeries();
172 172 m_chart->scroll(0,0);
173 173
174 174 m_chart->zoomIn();
175 175 m_chart->zoomIn(QRectF());
176 176 m_chart->zoomOut();
177 177 }
178 178
179 179 void tst_QChart::addSeries_data()
180 180 {
181 181 QTest::addColumn<QAbstractSeries *>("series");
182 182
183 183 QAbstractSeries* line = new QLineSeries(this);
184 184 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
185 185 QAbstractSeries* scatter = new QScatterSeries(this);
186 186 QAbstractSeries* spline = new QSplineSeries(this);
187 187 QAbstractSeries* pie = new QPieSeries(this);
188 188 QAbstractSeries* bar = new QBarSeries(this);
189 189 QAbstractSeries* percent = new QPercentBarSeries(this);
190 190 QAbstractSeries* stacked = new QStackedBarSeries(this);
191 191
192 192 QTest::newRow("lineSeries") << line;
193 193 QTest::newRow("areaSeries") << area;
194 194 QTest::newRow("scatterSeries") << scatter;
195 195 QTest::newRow("splineSeries") << spline;
196 196 QTest::newRow("pieSeries") << pie;
197 197 QTest::newRow("barSeries") << bar;
198 198 QTest::newRow("percentBarSeries") << percent;
199 199 QTest::newRow("stackedBarSeries") << stacked;
200 200
201 201 }
202 202
203 203 void tst_QChart::addSeries()
204 204 {
205 205 QFETCH(QAbstractSeries *, series);
206 206 m_view->show();
207 207 QTest::qWaitForWindowShown(m_view);
208 208 QVERIFY(!series->chart());
209 209 QCOMPARE(m_chart->series().count(), 0);
210 210 m_chart->addSeries(series);
211 211 QCOMPARE(m_chart->series().count(), 1);
212 212 QCOMPARE(m_chart->series().first(), series);
213 213 QVERIFY(series->chart() == m_chart);
214 214 m_chart->createDefaultAxes();
215 215 if(series->type()!=QAbstractSeries::SeriesTypePie){
216 216 QVERIFY(m_chart->axisY(series));
217 217 QVERIFY(m_chart->axisX(series));
218 218 }else{
219 219 QVERIFY(!m_chart->axisY(series));
220 220 QVERIFY(!m_chart->axisX(series));
221 221 }
222 222 m_chart->removeSeries(series);
223 223 QVERIFY(!series->chart());
224 224 QCOMPARE(m_chart->series().count(), 0);
225 225 }
226 226
227 227 void tst_QChart::animationOptions_data()
228 228 {
229 229 QTest::addColumn<QChart::AnimationOption>("animationOptions");
230 230 QTest::newRow("AllAnimations") << QChart::AllAnimations;
231 231 QTest::newRow("NoAnimation") << QChart::NoAnimation;
232 232 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
233 233 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
234 234 }
235 235
236 236 void tst_QChart::animationOptions()
237 237 {
238 238 createTestData();
239 239 QFETCH(QChart::AnimationOption, animationOptions);
240 240 m_chart->setAnimationOptions(animationOptions);
241 241 QCOMPARE(m_chart->animationOptions(), animationOptions);
242 242 }
243 243
244 244 void tst_QChart::axisX_data()
245 245 {
246 246
247 247 QTest::addColumn<QAbstractAxis*>("axis");
248 248 QTest::addColumn<QAbstractSeries *>("series");
249 249
250 QTest::newRow("categories,lineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QLineSeries(this);
251 QTest::newRow("categories,areaSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
252 QTest::newRow("categories,scatterSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QScatterSeries(this);
253 QTest::newRow("categories,splineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QSplineSeries(this);
254 QTest::newRow("categories,pieSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPieSeries(this);
255 QTest::newRow("categories,barSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QBarSeries(this);
256 QTest::newRow("categories,percentBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
257 QTest::newRow("categories,stackedBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
250 QTest::newRow("categories,lineSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
251 QTest::newRow("categories,areaSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
252 QTest::newRow("categories,scatterSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
253 QTest::newRow("categories,splineSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
254 QTest::newRow("categories,pieSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
255 QTest::newRow("categories,barSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
256 QTest::newRow("categories,percentBarSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
257 QTest::newRow("categories,stackedBarSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
258 258
259 259 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
260 260 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
261 261 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
262 262 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QSplineSeries(this);
263 263 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
264 264 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QBarSeries(this);
265 265 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
266 266 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
267 267
268 268 }
269 269
270 270 void tst_QChart::axisX()
271 271 {
272 272 QFETCH(QAbstractAxis*, axis);
273 273 QFETCH(QAbstractSeries*, series);
274 274 QVERIFY(!m_chart->axisX());
275 275 m_view->show();
276 276 QTest::qWaitForWindowShown(m_view);
277 277 m_chart->addSeries(series);
278 278 m_chart->setAxisX(axis,series);
279 279 QVERIFY(m_chart->axisX(series)==axis);
280 280 }
281 281
282 282 void tst_QChart::axisY_data()
283 283 {
284 284 axisX_data();
285 285 }
286 286
287 287
288 288 void tst_QChart::axisY()
289 289 {
290 290 QFETCH(QAbstractAxis*, axis);
291 291 QFETCH(QAbstractSeries*, series);
292 292 QVERIFY(!m_chart->axisY());
293 293 m_view->show();
294 294 QTest::qWaitForWindowShown(m_view);
295 295 m_chart->addSeries(series);
296 296 m_chart->setAxisY(axis,series);
297 297 QVERIFY(m_chart->axisY(series)==axis);
298 298 }
299 299
300 300 void tst_QChart::backgroundBrush_data()
301 301 {
302 302 QTest::addColumn<QBrush>("backgroundBrush");
303 303 QTest::newRow("null") << QBrush();
304 304 QTest::newRow("blue") << QBrush(Qt::blue);
305 305 QTest::newRow("white") << QBrush(Qt::white);
306 306 QTest::newRow("black") << QBrush(Qt::black);
307 307 }
308 308
309 309 void tst_QChart::backgroundBrush()
310 310 {
311 311 QFETCH(QBrush, backgroundBrush);
312 312 m_chart->setBackgroundBrush(backgroundBrush);
313 313 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
314 314 }
315 315
316 316 void tst_QChart::backgroundPen_data()
317 317 {
318 318 QTest::addColumn<QPen>("backgroundPen");
319 319 QTest::newRow("null") << QPen();
320 320 QTest::newRow("blue") << QPen(Qt::blue);
321 321 QTest::newRow("white") << QPen(Qt::white);
322 322 QTest::newRow("black") << QPen(Qt::black);
323 323 }
324 324
325 325
326 326 void tst_QChart::backgroundPen()
327 327 {
328 328 QFETCH(QPen, backgroundPen);
329 329 m_chart->setBackgroundPen(backgroundPen);
330 330 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
331 331 }
332 332
333 333 void tst_QChart::isBackgroundVisible_data()
334 334 {
335 335 QTest::addColumn<bool>("isBackgroundVisible");
336 336 QTest::newRow("true") << true;
337 337 QTest::newRow("false") << false;
338 338 }
339 339
340 340 void tst_QChart::isBackgroundVisible()
341 341 {
342 342 QFETCH(bool, isBackgroundVisible);
343 343 m_chart->setBackgroundVisible(isBackgroundVisible);
344 344 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
345 345 }
346 346
347 347 void tst_QChart::legend_data()
348 348 {
349 349
350 350 }
351 351
352 352 void tst_QChart::legend()
353 353 {
354 354 QLegend *legend = m_chart->legend();
355 355 QVERIFY(legend);
356 356
357 357 // Colors related signals
358 358 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
359 359 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
360 360 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
361 361
362 362 // colorChanged
363 363 legend->setColor(QColor("aliceblue"));
364 364 QCOMPARE(colorSpy.count(), 1);
365 365 QBrush b = legend->brush();
366 366 b.setColor(QColor("aqua"));
367 367 legend->setBrush(b);
368 368 QCOMPARE(colorSpy.count(), 2);
369 369
370 370 // borderColorChanged
371 371 legend->setBorderColor(QColor("aliceblue"));
372 372 QCOMPARE(borderColorSpy.count(), 1);
373 373 QPen p = legend->pen();
374 374 p.setColor(QColor("aqua"));
375 375 legend->setPen(p);
376 376 QCOMPARE(borderColorSpy.count(), 2);
377 377
378 378 // labelColorChanged
379 379 legend->setLabelColor(QColor("lightsalmon"));
380 380 QCOMPARE(labelColorSpy.count(), 1);
381 381 b = legend->labelBrush();
382 382 b.setColor(QColor("lightseagreen"));
383 383 legend->setLabelBrush(b);
384 384 QCOMPARE(labelColorSpy.count(), 2);
385 385
386 386 // fontChanged
387 387 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
388 388 QFont f = legend->font();
389 389 f.setBold(!f.bold());
390 390 legend->setFont(f);
391 391 QCOMPARE(fontSpy.count(), 1);
392 392 }
393 393
394 394 void tst_QChart::margins_data()
395 395 {
396 396
397 397 }
398 398
399 399 void tst_QChart::margins()
400 400 {
401 401 createTestData();
402 402 QRectF rect = m_chart->geometry();
403 403 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
404 404 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
405 405 }
406 406
407 407 void tst_QChart::removeAllSeries_data()
408 408 {
409 409
410 410 }
411 411
412 412 void tst_QChart::removeAllSeries()
413 413 {
414 414 QLineSeries* series0 = new QLineSeries(this);
415 415 QLineSeries* series1 = new QLineSeries(this);
416 416 QLineSeries* series2 = new QLineSeries(this);
417 417 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
418 418 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
419 419 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
420 420
421 421 m_chart->addSeries(series0);
422 422 m_chart->addSeries(series1);
423 423 m_chart->addSeries(series2);
424 424 m_view->show();
425 425 QTest::qWaitForWindowShown(m_view);
426 426 m_chart->createDefaultAxes();
427 427 QVERIFY(m_chart->axisY(series0)!=0);
428 428 QVERIFY(m_chart->axisY(series1)!=0);
429 429 QVERIFY(m_chart->axisY(series2)!=0);
430 430
431 431 m_chart->removeAllSeries();
432 432 QVERIFY(m_chart->axisY(series0)==0);
433 433 QVERIFY(m_chart->axisY(series1)==0);
434 434 QVERIFY(m_chart->axisY(series2)==0);
435 435 QCOMPARE(deleteSpy1.count(), 1);
436 436 QCOMPARE(deleteSpy2.count(), 1);
437 437 QCOMPARE(deleteSpy3.count(), 1);
438 438 }
439 439
440 440 void tst_QChart::removeSeries_data()
441 441 {
442 442 axisX_data();
443 443 }
444 444
445 445 void tst_QChart::removeSeries()
446 446 {
447 447 QFETCH(QAbstractAxis *, axis);
448 448 QFETCH(QAbstractSeries *, series);
449 449 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
450 450 m_view->show();
451 451 QTest::qWaitForWindowShown(m_view);
452 452 if(!axis) axis = m_chart->axisY();
453 453 m_chart->addSeries(series);
454 454 m_chart->setAxisY(axis,series);
455 455 QCOMPARE(m_chart->axisY(series),axis);
456 456 m_chart->removeSeries(series);
457 457 QVERIFY(m_chart->axisY(series)==0);
458 458 QCOMPARE(deleteSpy.count(), 0);
459 459 }
460 460
461 461 void tst_QChart::scroll_right_data()
462 462 {
463 463 QTest::addColumn<QAbstractSeries *>("series");
464 464
465 465 QLineSeries* series0 = new QLineSeries(this);
466 466 *series0 << QPointF(0, 0) << QPointF(100, 100);
467 467
468 468 QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
469 469
470 470
471 471 }
472 472
473 473 void tst_QChart::scroll_right()
474 474 {
475 475 QFETCH(QAbstractSeries *, series);
476 476 m_chart->addSeries(series);
477 477 m_chart->createDefaultAxes();
478 478 m_view->show();
479 479 QTest::qWaitForWindowShown(m_view);
480 480 QAbstractAxis * axis = m_chart->axisX();
481 481 QVERIFY(axis!=0);
482 482
483 483 switch(axis->type())
484 484 {
485 485 case QAbstractAxis::AxisTypeValues:{
486 486 QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
487 487 QVERIFY(vaxis!=0);
488 488 qreal min = vaxis->min();
489 489 qreal max = vaxis->max();
490 490 QVERIFY(max>min);
491 491 m_chart->scroll(50, 0);
492 492 QVERIFY(min<vaxis->min());
493 493 QVERIFY(max<vaxis->max());
494 494 break;
495 495 }
496 496 case QAbstractAxis::AxisTypeCategories:{
497 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
497 QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
498 498 QVERIFY(caxis!=0);
499 499 qreal min = caxis->min().toDouble();
500 500 qreal max = caxis->max().toDouble();
501 501 m_chart->scroll(50, 0);
502 502 QVERIFY(min<caxis->min().toDouble());
503 503 QVERIFY(max<caxis->max().toDouble());
504 504 break;
505 505 }
506 506 default:
507 507 qFatal("Unsupported type");
508 508 break;
509 509 }
510 510 }
511 511
512 512 void tst_QChart::scroll_left_data()
513 513 {
514 514 scroll_right_data();
515 515 }
516 516
517 517 void tst_QChart::scroll_left()
518 518 {
519 519 QFETCH(QAbstractSeries *, series);
520 520 m_chart->addSeries(series);
521 521 m_chart->createDefaultAxes();
522 522 m_view->show();
523 523 QTest::qWaitForWindowShown(m_view);
524 524 QAbstractAxis * axis = m_chart->axisX();
525 525 QVERIFY(axis!=0);
526 526
527 527 switch(axis->type())
528 528 {
529 529 case QAbstractAxis::AxisTypeValues:{
530 530 QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
531 531 QVERIFY(vaxis!=0);
532 532 qreal min = vaxis->min();
533 533 qreal max = vaxis->max();
534 534 m_chart->scroll(-50, 0);
535 535 QVERIFY(min>vaxis->min());
536 536 QVERIFY(max>vaxis->max());
537 537 break;
538 538 }
539 539 case QAbstractAxis::AxisTypeCategories:{
540 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
540 QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
541 541 QVERIFY(caxis!=0);
542 542 qreal min = caxis->min().toDouble();
543 543 qreal max = caxis->max().toDouble();
544 544 m_chart->scroll(-50, 0);
545 545 QVERIFY(min>caxis->min().toDouble());
546 546 QVERIFY(max>caxis->max().toDouble());
547 547 break;
548 548 }
549 549 default:
550 550 qFatal("Unsupported type");
551 551 break;
552 552 }
553 553 }
554 554
555 555 void tst_QChart::scroll_up_data()
556 556 {
557 557 scroll_right_data();
558 558 }
559 559
560 560 void tst_QChart::scroll_up()
561 561 {
562 562 QFETCH(QAbstractSeries *, series);
563 563 m_chart->addSeries(series);
564 564 m_chart->createDefaultAxes();
565 565 m_view->show();
566 566 QTest::qWaitForWindowShown(m_view);
567 567 QAbstractAxis * axis = m_chart->axisY();
568 568 QVERIFY(axis!=0);
569 569
570 570 switch(axis->type())
571 571 {
572 572 case QAbstractAxis::AxisTypeValues:{
573 573 QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
574 574 QVERIFY(vaxis!=0);
575 575 qreal min = vaxis->min();
576 576 qreal max = vaxis->max();
577 577 m_chart->scroll(0, 50);
578 578 QVERIFY(min<vaxis->min());
579 579 QVERIFY(max<vaxis->max());
580 580 break;
581 581 }
582 582 case QAbstractAxis::AxisTypeCategories:{
583 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
583 QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
584 584 QVERIFY(caxis!=0);
585 585 qreal min = caxis->min().toDouble();
586 586 qreal max = caxis->max().toDouble();
587 587 m_chart->scroll(0, 50);
588 588 QVERIFY(min<caxis->min().toDouble());
589 589 QVERIFY(max<caxis->max().toDouble());
590 590 break;
591 591 }
592 592 default:
593 593 qFatal("Unsupported type");
594 594 break;
595 595 }
596 596 }
597 597
598 598 void tst_QChart::scroll_down_data()
599 599 {
600 600 scroll_right_data();
601 601 }
602 602
603 603 void tst_QChart::scroll_down()
604 604 {
605 605 QFETCH(QAbstractSeries *, series);
606 606 m_chart->addSeries(series);
607 607 m_chart->createDefaultAxes();
608 608 m_view->show();
609 609 QTest::qWaitForWindowShown(m_view);
610 610 QAbstractAxis * axis = m_chart->axisY();
611 611 QVERIFY(axis!=0);
612 612
613 613 switch(axis->type())
614 614 {
615 615 case QAbstractAxis::AxisTypeValues:{
616 616 QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
617 617 QVERIFY(vaxis!=0);
618 618 qreal min = vaxis->min();
619 619 qreal max = vaxis->max();
620 620 m_chart->scroll(0, -50);
621 621 QVERIFY(min>vaxis->min());
622 622 QVERIFY(max>vaxis->max());
623 623 break;
624 624 }
625 625 case QAbstractAxis::AxisTypeCategories:{
626 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
626 QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
627 627 QVERIFY(caxis!=0);
628 628 qreal min = caxis->min().toDouble();
629 629 qreal max = caxis->max().toDouble();
630 630 m_chart->scroll(0, -50);
631 631 QVERIFY(min>caxis->min().toDouble());
632 632 QVERIFY(max>caxis->max().toDouble());
633 633 break;
634 634 }
635 635 default:
636 636 qFatal("Unsupported type");
637 637 break;
638 638 }
639 639 }
640 640
641 641 void tst_QChart::theme_data()
642 642 {
643 643 QTest::addColumn<QChart::ChartTheme>("theme");
644 644 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
645 645 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
646 646 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
647 647 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
648 648 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
649 649 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
650 650 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
651 651 }
652 652
653 653 void tst_QChart::theme()
654 654 {
655 655 QFETCH(QChart::ChartTheme, theme);
656 656 createTestData();
657 657 m_chart->setTheme(theme);
658 658 QVERIFY(m_chart->theme()==theme);
659 659 }
660 660
661 661 void tst_QChart::title_data()
662 662 {
663 663 QTest::addColumn<QString>("title");
664 664 QTest::newRow("null") << QString();
665 665 QTest::newRow("foo") << QString("foo");
666 666 }
667 667
668 668 void tst_QChart::title()
669 669 {
670 670 QFETCH(QString, title);
671 671 m_chart->setTitle(title);
672 672 QCOMPARE(m_chart->title(), title);
673 673 }
674 674
675 675 void tst_QChart::titleBrush_data()
676 676 {
677 677 QTest::addColumn<QBrush>("titleBrush");
678 678 QTest::newRow("null") << QBrush();
679 679 QTest::newRow("blue") << QBrush(Qt::blue);
680 680 QTest::newRow("white") << QBrush(Qt::white);
681 681 QTest::newRow("black") << QBrush(Qt::black);
682 682 }
683 683
684 684 void tst_QChart::titleBrush()
685 685 {
686 686 QFETCH(QBrush, titleBrush);
687 687 m_chart->setTitleBrush(titleBrush);
688 688 QCOMPARE(m_chart->titleBrush(), titleBrush);
689 689 }
690 690
691 691 void tst_QChart::titleFont_data()
692 692 {
693 693 QTest::addColumn<QFont>("titleFont");
694 694 QTest::newRow("null") << QFont();
695 695 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
696 696 }
697 697
698 698 void tst_QChart::titleFont()
699 699 {
700 700 QFETCH(QFont, titleFont);
701 701 m_chart->setTitleFont(titleFont);
702 702 QCOMPARE(m_chart->titleFont(), titleFont);
703 703 }
704 704
705 705 void tst_QChart::zoomIn_data()
706 706 {
707 707 QTest::addColumn<QRectF>("rect");
708 708 QTest::newRow("null") << QRectF();
709 709 QTest::newRow("100x100") << QRectF(10,10,100,100);
710 710 QTest::newRow("200x200") << QRectF(10,10,200,200);
711 711 }
712 712
713 713
714 714 void tst_QChart::zoomIn()
715 715 {
716 716
717 717 QFETCH(QRectF, rect);
718 718 createTestData();
719 719 m_chart->createDefaultAxes();
720 720 QRectF marigns = m_chart->margins();
721 721 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
722 722 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
723 723 QVERIFY(axisX!=0);
724 724 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
725 725 QVERIFY(axisY!=0);
726 726 qreal minX = axisX->min();
727 727 qreal minY = axisY->min();
728 728 qreal maxX = axisX->max();
729 729 qreal maxY = axisY->max();
730 730 m_chart->zoomIn(rect);
731 731 if(rect.isValid()){
732 732 QVERIFY(minX<axisX->min());
733 733 QVERIFY(maxX>axisX->max());
734 734 QVERIFY(minY<axisY->min());
735 735 QVERIFY(maxY>axisY->max());
736 736 }
737 737
738 738 }
739 739
740 740 void tst_QChart::zoomOut_data()
741 741 {
742 742
743 743 }
744 744
745 745 void tst_QChart::zoomOut()
746 746 {
747 747 createTestData();
748 748 m_chart->createDefaultAxes();
749 749
750 750 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
751 751 QVERIFY(axisX!=0);
752 752 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
753 753 QVERIFY(axisY!=0);
754 754
755 755 qreal minX = axisX->min();
756 756 qreal minY = axisY->min();
757 757 qreal maxX = axisX->max();
758 758 qreal maxY = axisY->max();
759 759
760 760 m_chart->zoomIn();
761 761
762 762 QVERIFY(minX < axisX->min());
763 763 QVERIFY(maxX > axisX->max());
764 764 QVERIFY(minY < axisY->min());
765 765 QVERIFY(maxY > axisY->max());
766 766
767 767 m_chart->zoomOut();
768 768
769 769 // min x may be a zero value
770 770 if (qFuzzyIsNull(minX))
771 771 QVERIFY(qFuzzyIsNull(axisX->min()));
772 772 else
773 773 QCOMPARE(minX, axisX->min());
774 774
775 775 // min y may be a zero value
776 776 if (qFuzzyIsNull(minY))
777 777 QVERIFY(qFuzzyIsNull(axisY->min()));
778 778 else
779 779 QCOMPARE(minY, axisY->min());
780 780
781 781 QVERIFY(maxX == axisX->max());
782 782 QVERIFY(maxY == axisY->max());
783 783
784 784 }
785 785
786 786 QTEST_MAIN(tst_QChart)
787 787 #include "tst_qchart.moc"
788 788
Show file before | Show file after | Hide comments
@@ -1,376 +1,376
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "mainwidget.h"
22 22 #include "dataseriedialog.h"
23 23 #include "qchartview.h"
24 24 #include "qpieseries.h"
25 25 #include "qscatterseries.h"
26 26 #include "qlineseries.h"
27 27 #include <qareaseries.h>
28 28 #include <qsplineseries.h>
29 29 #include <qbarset.h>
30 30 #include <qbarseries.h>
31 31 #include <qstackedbarseries.h>
32 32 #include <qpercentbarseries.h>
33 33 #include <QPushButton>
34 34 #include <QComboBox>
35 35 #include <QSpinBox>
36 36 #include <QCheckBox>
37 37 #include <QGridLayout>
38 38 #include <QHBoxLayout>
39 39 #include <QLabel>
40 40 #include <QSpacerItem>
41 41 #include <QMessageBox>
42 42 #include <cmath>
43 43 #include <QDebug>
44 44 #include <QStandardItemModel>
45 45 #include <QBarCategoriesAxis>
46 46 #include <QGLWidget>
47 47
48 48 QTCOMMERCIALCHART_USE_NAMESPACE
49 49
50 50 MainWidget::MainWidget(QWidget *parent) :
51 51 QWidget(parent),
52 52 m_addSerieDialog(0),
53 53 m_chart(0)
54 54 {
55 55 m_chart = new QChart();
56 56
57 57 // Grid layout for the controls for configuring the chart widget
58 58 QGridLayout *grid = new QGridLayout();
59 59 QPushButton *addSeriesButton = new QPushButton("Add series");
60 60 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
61 61 grid->addWidget(addSeriesButton, 0, 1);
62 62 initBackroundCombo(grid);
63 63 initScaleControls(grid);
64 64 initThemeCombo(grid);
65 65 initCheckboxes(grid);
66 66
67 67 // add row with empty label to make all the other rows static
68 68 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
69 69 grid->setRowStretch(grid->rowCount() - 1, 1);
70 70
71 71 // Create chart view with the chart
72 72 m_chartView = new QChartView(m_chart, this);
73 73 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
74 74
75 75 // Another grid layout as a main layout
76 76 QGridLayout *mainLayout = new QGridLayout();
77 77 mainLayout->addLayout(grid, 0, 0);
78 78 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
79 79 setLayout(mainLayout);
80 80 }
81 81
82 82 // Combo box for selecting the chart's background
83 83 void MainWidget::initBackroundCombo(QGridLayout *grid)
84 84 {
85 85 QComboBox *backgroundCombo = new QComboBox(this);
86 86 backgroundCombo->addItem("Color");
87 87 backgroundCombo->addItem("Gradient");
88 88 backgroundCombo->addItem("Image");
89 89 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
90 90 this, SLOT(backgroundChanged(int)));
91 91
92 92 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
93 93 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
94 94 }
95 95
96 96 // Scale related controls (auto-scale vs. manual min-max values)
97 97 void MainWidget::initScaleControls(QGridLayout *grid)
98 98 {
99 99 m_autoScaleCheck = new QCheckBox("Automatic scaling");
100 100 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
101 101 // Allow setting also non-sense values (like -2147483648 and 2147483647)
102 102 m_xMinSpin = new QSpinBox();
103 103 m_xMinSpin->setMinimum(INT_MIN);
104 104 m_xMinSpin->setMaximum(INT_MAX);
105 105 m_xMinSpin->setValue(0);
106 106 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
107 107 m_xMaxSpin = new QSpinBox();
108 108 m_xMaxSpin->setMinimum(INT_MIN);
109 109 m_xMaxSpin->setMaximum(INT_MAX);
110 110 m_xMaxSpin->setValue(10);
111 111 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
112 112 m_yMinSpin = new QSpinBox();
113 113 m_yMinSpin->setMinimum(INT_MIN);
114 114 m_yMinSpin->setMaximum(INT_MAX);
115 115 m_yMinSpin->setValue(0);
116 116 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
117 117 m_yMaxSpin = new QSpinBox();
118 118 m_yMaxSpin->setMinimum(INT_MIN);
119 119 m_yMaxSpin->setMaximum(INT_MAX);
120 120 m_yMaxSpin->setValue(10);
121 121 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
122 122
123 123 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
124 124 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
125 125 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
126 126 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
127 127 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
128 128 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
129 129 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
130 130 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
131 131 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
132 132
133 133 m_autoScaleCheck->setChecked(true);
134 134 }
135 135
136 136 // Combo box for selecting theme
137 137 void MainWidget::initThemeCombo(QGridLayout *grid)
138 138 {
139 139 QComboBox *chartTheme = new QComboBox();
140 140 chartTheme->addItem("Default");
141 141 chartTheme->addItem("Light");
142 142 chartTheme->addItem("Blue Cerulean");
143 143 chartTheme->addItem("Dark");
144 144 chartTheme->addItem("Brown Sand");
145 145 chartTheme->addItem("Blue NCS");
146 146 chartTheme->addItem("High Contrast");
147 147 chartTheme->addItem("Blue Icy");
148 148 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
149 149 this, SLOT(changeChartTheme(int)));
150 150 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
151 151 grid->addWidget(chartTheme, 8, 1);
152 152 }
153 153
154 154 // Different check boxes for customizing chart
155 155 void MainWidget::initCheckboxes(QGridLayout *grid)
156 156 {
157 157 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
158 158 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
159 159 // connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
160 160 zoomCheckBox->setChecked(true);
161 161 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
162 162
163 163 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
164 164 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
165 165 aliasCheckBox->setChecked(false);
166 166 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
167 167
168 168 QCheckBox *openGLCheckBox = new QCheckBox("Use QGLWidget");
169 169 connect(openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(openGLToggled(bool)));
170 170 openGLCheckBox->setChecked(false);
171 171 grid->addWidget(openGLCheckBox, grid->rowCount(), 0);
172 172 }
173 173
174 174 void MainWidget::antiAliasToggled(bool enabled)
175 175 {
176 176 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
177 177 }
178 178
179 179 void MainWidget::openGLToggled(bool enabled)
180 180 {
181 181 if (enabled) {
182 182 QGLFormat f = QGLFormat::defaultFormat();
183 183 f.setSampleBuffers(true);
184 184 f.setSamples(4);
185 185 QGLFormat::setDefaultFormat(f);
186 186 QGLWidget *g = new QGLWidget();
187 187 m_chartView->setViewport(g);
188 188 } else {
189 189 m_chartView->setViewport(0);
190 190 }
191 191 }
192 192
193 193 void MainWidget::addSeries()
194 194 {
195 195 if (!m_addSerieDialog) {
196 196 m_addSerieDialog = new DataSerieDialog(this);
197 197 connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
198 198 this, SLOT(addSeries(QString,int,int,QString,bool)));
199 199 }
200 200 m_addSerieDialog->exec();
201 201 }
202 202
203 203 QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
204 204 {
205 205 // TODO: dataCharacteristics
206 206 QList<RealList> testData;
207 207 for (int j(0); j < columnCount; j++) {
208 208 QList <qreal> newColumn;
209 209 for (int i(0); i < rowCount; i++) {
210 210 if (dataCharacteristics == "Sin") {
211 211 newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
212 212 } else if (dataCharacteristics == "Sin + random") {
213 213 newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
214 214 } else if (dataCharacteristics == "Random") {
215 215 newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
216 216 } else if (dataCharacteristics == "Linear") {
217 217 //newColumn.append(i * (j + 1.0));
218 218 // TODO: temporary hack to make pie work; prevent zero values:
219 219 newColumn.append(i * (j + 1.0) + 0.1);
220 220 } else { // "constant"
221 221 newColumn.append((j + 1.0));
222 222 }
223 223 }
224 224 testData.append(newColumn);
225 225 }
226 226 return testData;
227 227 }
228 228
229 229 QStringList MainWidget::generateLabels(int count)
230 230 {
231 231 QStringList result;
232 232 for (int i(0); i < count; i++)
233 233 result.append("label" + QString::number(i));
234 234 return result;
235 235 }
236 236
237 237 void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
238 238 {
239 239 qDebug() << "addSeries: " << seriesName
240 240 << " columnCount: " << columnCount
241 241 << " rowCount: " << rowCount
242 242 << " dataCharacteristics: " << dataCharacteristics
243 243 << " labels enabled: " << labelsEnabled;
244 244 m_defaultSeriesName = seriesName;
245 245
246 246 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
247 247
248 248 // Line series and scatter series use similar data
249 249 if (seriesName == "Line") {
250 250 for (int j(0); j < data.count(); j ++) {
251 251 QList<qreal> column = data.at(j);
252 252 QLineSeries *series = new QLineSeries();
253 253 series->setName("line" + QString::number(j));
254 254 for (int i(0); i < column.count(); i++)
255 255 series->append(i, column.at(i));
256 256 m_chart->addSeries(series);
257 257 }
258 258 } else if (seriesName == "Area") {
259 259 // TODO: lower series for the area?
260 260 for (int j(0); j < data.count(); j ++) {
261 261 QList<qreal> column = data.at(j);
262 262 QLineSeries *lineSeries = new QLineSeries();
263 263 for (int i(0); i < column.count(); i++)
264 264 lineSeries->append(i, column.at(i));
265 265 QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
266 266 areaSeries->setName("area" + QString::number(j));
267 267 m_chart->addSeries(areaSeries);
268 268 }
269 269 } else if (seriesName == "Scatter") {
270 270 for (int j(0); j < data.count(); j++) {
271 271 QList<qreal> column = data.at(j);
272 272 QScatterSeries *series = new QScatterSeries();
273 273 series->setName("scatter" + QString::number(j));
274 274 for (int i(0); i < column.count(); i++)
275 275 series->append(i, column.at(i));
276 276 m_chart->addSeries(series);
277 277 }
278 278 } else if (seriesName == "Pie") {
279 279 QStringList labels = generateLabels(rowCount);
280 280 for (int j(0); j < data.count(); j++) {
281 281 QPieSeries *series = new QPieSeries();
282 282 QList<qreal> column = data.at(j);
283 283 for (int i(0); i < column.count(); i++)
284 284 series->append(labels.at(i), column.at(i));
285 285 m_chart->addSeries(series);
286 286 }
287 287 } else if (seriesName == "Bar"
288 288 || seriesName == "Stacked bar"
289 289 || seriesName == "Percent bar") {
290 290 QStringList category;
291 291 QStringList labels = generateLabels(rowCount);
292 292 foreach(QString label, labels)
293 293 category << label;
294 294 QAbstractBarSeries* series = 0;
295 295 if (seriesName == "Bar") {
296 296 series = new QBarSeries(this);
297 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
297 QBarCategoryAxis* axis = new QBarCategoryAxis();
298 298 axis->append(category);
299 299 m_chart->setAxisX(axis,series);
300 300 } else if (seriesName == "Stacked bar") {
301 301 series = new QStackedBarSeries(this);
302 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
302 QBarCategoryAxis* axis = new QBarCategoryAxis();
303 303 axis->append(category);
304 304 m_chart->setAxisX(axis,series);
305 305 } else {
306 306 series = new QPercentBarSeries(this);
307 QBarCategoriesAxis* axis = new QBarCategoriesAxis();
307 QBarCategoryAxis* axis = new QBarCategoryAxis();
308 308 axis->append(category);
309 309 m_chart->setAxisX(axis,series);
310 310 }
311 311
312 312 for (int j(0); j < data.count(); j++) {
313 313 QList<qreal> column = data.at(j);
314 314 QBarSet *set = new QBarSet("set" + QString::number(j));
315 315 for (int i(0); i < column.count(); i++)
316 316 *set << column.at(i);
317 317 series->append(set);
318 318 }
319 319
320 320 m_chart->addSeries(series);
321 321 } else if (seriesName == "Spline") {
322 322 for (int j(0); j < data.count(); j ++) {
323 323 QList<qreal> column = data.at(j);
324 324 QSplineSeries *series = new QSplineSeries();
325 325 for (int i(0); i < column.count(); i++)
326 326 series->append(i, column.at(i));
327 327 m_chart->addSeries(series);
328 328 }
329 329 }
330 330 m_chart->createDefaultAxes();
331 331 }
332 332
333 333 void MainWidget::backgroundChanged(int itemIndex)
334 334 {
335 335 qDebug() << "backgroundChanged: " << itemIndex;
336 336 }
337 337
338 338 void MainWidget::autoScaleChanged(int value)
339 339 {
340 340 if (value) {
341 341 // TODO: enable auto scaling
342 342 } else {
343 343 // TODO: set scaling manually (and disable auto scaling)
344 344 }
345 345
346 346 m_xMinSpin->setEnabled(!value);
347 347 m_xMaxSpin->setEnabled(!value);
348 348 m_yMinSpin->setEnabled(!value);
349 349 m_yMaxSpin->setEnabled(!value);
350 350 }
351 351
352 352 void MainWidget::xMinChanged(int value)
353 353 {
354 354 qDebug() << "xMinChanged: " << value;
355 355 }
356 356
357 357 void MainWidget::xMaxChanged(int value)
358 358 {
359 359 qDebug() << "xMaxChanged: " << value;
360 360 }
361 361
362 362 void MainWidget::yMinChanged(int value)
363 363 {
364 364 qDebug() << "yMinChanged: " << value;
365 365 }
366 366
367 367 void MainWidget::yMaxChanged(int value)
368 368 {
369 369 qDebug() << "yMaxChanged: " << value;
370 370 }
371 371
372 372 void MainWidget::changeChartTheme(int themeIndex)
373 373 {
374 374 qDebug() << "changeChartTheme: " << themeIndex;
375 375 m_chart->setTheme((QChart::ChartTheme) themeIndex);
376 376 }
General Comments 0
You need to be logged in to leave comments. Login now