@@ -1,110 +1,110 | |||
|
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 "declarativemodel.h" |
|
22 | 22 | #include <qdeclarativelist.h> |
|
23 | 23 | #include <QStringList> |
|
24 | 24 | #include <QDebug> |
|
25 | 25 | |
|
26 | 26 | ////////////// Table model element /////////////////// |
|
27 | 27 | |
|
28 | 28 | DeclarativeTableModelElement::DeclarativeTableModelElement(QObject *parent) |
|
29 | 29 | : QObject(parent) |
|
30 | 30 | { |
|
31 | 31 | } |
|
32 | 32 | |
|
33 | 33 | QVariantList DeclarativeTableModelElement::values() |
|
34 | 34 | { |
|
35 | 35 | return m_values; |
|
36 | 36 | } |
|
37 | 37 | |
|
38 | 38 | void DeclarativeTableModelElement::setValues(QVariantList values) |
|
39 | 39 | { |
|
40 | 40 | m_values = values; |
|
41 | 41 | } |
|
42 | 42 | |
|
43 | 43 | ////////////// Table model /////////////////// |
|
44 | 44 | |
|
45 | 45 | DeclarativeTableModel::DeclarativeTableModel(QObject *parent) : |
|
46 | 46 | CustomTableModel(parent) |
|
47 | 47 | { |
|
48 | 48 | } |
|
49 | 49 | |
|
50 | 50 | void DeclarativeTableModel::classBegin() |
|
51 | 51 | { |
|
52 | 52 | } |
|
53 | 53 | |
|
54 | 54 | void DeclarativeTableModel::componentComplete() |
|
55 | 55 | { |
|
56 | 56 | foreach (QObject *child, children()) { |
|
57 | 57 | if (qobject_cast<DeclarativeTableModelElement *>(child)) { |
|
58 | 58 | DeclarativeTableModelElement *element = qobject_cast<DeclarativeTableModelElement *>(child); |
|
59 | 59 | append(element->values()); |
|
60 | 60 | } |
|
61 | 61 | } |
|
62 | 62 | } |
|
63 | 63 | |
|
64 | 64 | void DeclarativeTableModel::setVerticalHeaders(QStringList headers) |
|
65 | 65 | { |
|
66 | 66 | for (int i(0); i < headers.count(); i++) |
|
67 | 67 | setHeaderData(i, Qt::Vertical, headers.at(i)); |
|
68 | 68 | } |
|
69 | 69 | |
|
70 | 70 | QStringList DeclarativeTableModel::verticalHeaders() |
|
71 | 71 | { |
|
72 | 72 | return QStringList(); |
|
73 | 73 | } |
|
74 | 74 | |
|
75 | 75 | QDeclarativeListProperty<QObject> DeclarativeTableModel::modelChildren() |
|
76 | 76 | { |
|
77 | 77 | return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeTableModel::appendModelChild); |
|
78 | 78 | } |
|
79 | 79 | |
|
80 | 80 | void DeclarativeTableModel::appendModelChild(QDeclarativeListProperty<QObject> *list, |
|
81 | 81 | QObject *child) |
|
82 | 82 | { |
|
83 |
// child |
|
|
83 | // children are added in componentComplete instead | |
|
84 | 84 | Q_UNUSED(list) |
|
85 | 85 | Q_UNUSED(child) |
|
86 | 86 | } |
|
87 | 87 | |
|
88 | 88 | void DeclarativeTableModel::append(QVariantList values) |
|
89 | 89 | { |
|
90 | 90 | // qDebug() << "DeclarativeTableModel::append:" << values; |
|
91 | 91 | |
|
92 | 92 | while (columnCount() < values.count()) |
|
93 | 93 | insertColumn(columnCount()); |
|
94 | 94 | |
|
95 | 95 | insertRow(rowCount()); |
|
96 | 96 | |
|
97 | 97 | QModelIndex beginIndex = QModelIndex(); |
|
98 | 98 | QModelIndex endIndex = QModelIndex(); |
|
99 | 99 | for (int i(0); i < values.count(); i++) { |
|
100 | 100 | QModelIndex modelIndex = createIndex(rowCount() - 1, i); |
|
101 | 101 | if (i == 0) |
|
102 | 102 | beginIndex = modelIndex; |
|
103 | 103 | if (i == (values.count() - 1)) |
|
104 | 104 | endIndex = modelIndex; |
|
105 | 105 | setData(modelIndex, values.at(i)); |
|
106 | 106 | } |
|
107 | 107 | dataChanged(beginIndex, endIndex); |
|
108 | 108 | } |
|
109 | 109 | |
|
110 | 110 | #include "moc_declarativemodel.cpp" |
@@ -1,49 +1,49 | |||
|
1 | 1 | /*! |
|
2 | 2 | \example demos/nesteddonuts |
|
3 | 3 | \title Nested donuts demo |
|
4 | 4 | \subtitle |
|
5 | 5 | |
|
6 | 6 | This example shows how to use create a nested donuts chart using QPieSeries API. |
|
7 | 7 | \image examples_donutchart.png |
|
8 | 8 | |
|
9 | 9 | Let's start by creating a QChartView instance and enabling the Antialiasing on it. Last line enables the animations of the chart. |
|
10 | 10 | |
|
11 | 11 | \snippet ../demos/nesteddonuts/widget.cpp 1 |
|
12 | 12 | |
|
13 | 13 | Three variables are defined that will be used to define the donut chart. Min and max size define the relative size of the whole donut. |
|
14 | 14 | minSize is the relative inner size of the smallest donut. maxSize is the relative outer size of the biggest donut. |
|
15 | 15 | |
|
16 | 16 | \snippet ../demos/nesteddonuts/widget.cpp 2 |
|
17 | 17 | |
|
18 | 18 | Following block of code defines the individual donuts and their slices. First new QPieSeries object is created. |
|
19 | 19 | Callign setDonut() changes pie into a donut. The number of slices in each donut is randomized. |
|
20 | 20 | The internal for loop creates the slices with a random value and label same as the value. |
|
21 | 21 | Next the label of the slice is set to be visible and its color is set to white. |
|
22 | 22 | To make the example more interesting the hovered signal of the slice is connected to widget's slot which inner workings are explained later. |
|
23 | Finally the slice is added to the donut. The donut's size is adjusted to achive the nesting of the donuts. | |
|
23 | Finally the slice is added to the donut. The donut's size is adjusted to achieve the nesting of the donuts. | |
|
24 | 24 | Then the donut is added to the widget's list of donuts and to the chart. |
|
25 | 25 | |
|
26 | 26 | \snippet ../demos/nesteddonuts/widget.cpp 3 |
|
27 | 27 | |
|
28 | 28 | Finally the widget is placed in a layout used by the application. |
|
29 | 29 | |
|
30 | 30 | \snippet ../demos/nesteddonuts/widget.cpp 4 |
|
31 | 31 | |
|
32 | 32 | To make the example more interesting the donuts are rotated randomly every 1.25 sec. |
|
33 | 33 | |
|
34 | 34 | \snippet ../demos/nesteddonuts/widget.cpp 5 |
|
35 | 35 | |
|
36 | 36 | The widget's updatedRotation slot is defined below. |
|
37 | 37 | It goes through all of the donuts and modifies thier current rotation by a random value. |
|
38 | 38 | |
|
39 | 39 | \snippet ../demos/nesteddonuts/widget.cpp 6 |
|
40 | 40 | |
|
41 | 41 | The earlier mentioned explodeSlice slot code is provided below. |
|
42 | 42 | If the slice is set to exploded then stop the timer that controls the donuts rotation. |
|
43 | 43 | Then the slice's start and end agles are obtained from the slice. |
|
44 | 44 | To highlight the selected slice all the other donuts that lie outward from the one that contains the selected slice |
|
45 | 45 | have their start and end angles modified so that they wouldn't "block" the way for the hightlighted slice. |
|
46 | 46 | If the slice is no longer selected return to the original state. |
|
47 | 47 | |
|
48 | 48 | \snippet ../demos/nesteddonuts/widget.cpp 7 |
|
49 | 49 | */ |
@@ -1,45 +1,45 | |||
|
1 | 1 | /*! |
|
2 | 2 | \example examples/stackedbarchartdrilldown |
|
3 | 3 | \title StackedBarChart Drilldown Example |
|
4 | 4 | \subtitle |
|
5 | 5 | |
|
6 | 6 | The example shows how to implement drilldown using stacked barchart. In drilldown example we create stacked barchart, which shows the harvest of various chili peppers during season. In season view the harvest is grouped by month. To drill down to weekly view, user clicks selected month with right mouse button. On weekly view, the harvest of clicked month is shown by week. For example purposes each month is 4 weeks long :) |
|
7 | 7 | |
|
8 | 8 | Season view looks like this: |
|
9 | 9 | \image examples_stackedbarchartdrilldown1.png |
|
10 | 10 | |
|
11 | 11 | Mouse button clicked on a month, shows the harvest from that month: |
|
12 | 12 | \image examples_stackedbarchartdrilldown2.png |
|
13 | 13 | |
|
14 | 14 | First we define a drilldown series class, which adds categories to stacked bar series and mapping for categories to other drilldown series. |
|
15 | 15 | Purpose of drilldown series is to contain knowledge of the drilldown structure. The mapDrilldownSeries function maps the category to given series. We can ask the mapping for category with drilldownSeries(int category) function. |
|
16 | 16 | |
|
17 | 17 | \snippet ../examples/stackedbarchartdrilldown/drilldownseries.h 1 |
|
18 | 18 | |
|
19 | 19 | Next we define our own drilldown chart, which implements handler for mouse click. All QBarSeries derived classes send out clicked(QBarSet*, int) signal when series is clicked with mouse. The parameter QBarSet contains pointer to clicked bar set and parameter int contains the index of clicked category. |
|
20 | 20 | |
|
21 | 21 | \snippet ../examples/stackedbarchartdrilldown/drilldownchart.h 1 |
|
22 | 22 | |
|
23 | 23 | Now we have our drilldown classes and we can start using them. |
|
24 | 24 | First create the chart. |
|
25 | 25 | |
|
26 | 26 | \snippet ../examples/stackedbarchartdrilldown/main.cpp 1 |
|
27 | 27 | |
|
28 |
|
|
|
28 | We define categories, from which the drilldown series will be constructed. | |
|
29 | 29 | |
|
30 | 30 | \snippet ../examples/stackedbarchartdrilldown/main.cpp 2 |
|
31 | 31 | |
|
32 | 32 | To create the drilldown structure, we first create our top level series, which we call seasonSeries. For each month in seasonSeries we create a drilldown series, called weeklySeries which contains more detailed data for that month. |
|
33 | 33 | In weeklySeries, we use the drilldown handler to bring us back to seasonSeries. To do this we add mapping to the series. The seasonSeries is mapped to weeklySeries for each month. Every weeklySeries is mapped back to the seasonSeries. |
|
34 | 34 | To make mapping work, we connect the clicked signals from our series to the drilldownChart. |
|
35 | 35 | |
|
36 | 36 | \snippet ../examples/stackedbarchartdrilldown/main.cpp 3 |
|
37 | 37 | |
|
38 | 38 | When we have our drilldown structure ready, we can add the data to it. Here we generate random crop for each plant in each week. The monthly crop is calculated from weekly crops and is set as value to monthly series. |
|
39 | 39 | |
|
40 | 40 | \snippet ../examples/stackedbarchartdrilldown/main.cpp 4 |
|
41 | 41 | |
|
42 | 42 | Here we set the chart to show top level series initially. |
|
43 | 43 | |
|
44 | 44 | \snippet ../examples/stackedbarchartdrilldown/main.cpp 5 |
|
45 | 45 | */ |
@@ -1,99 +1,99 | |||
|
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 "declarativelineseries.h" |
|
22 | 22 | |
|
23 | 23 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
24 | 24 | |
|
25 | 25 | DeclarativeLineSeries::DeclarativeLineSeries(QObject *parent) : |
|
26 | 26 | QLineSeries(parent), |
|
27 | 27 | m_axisX(0), |
|
28 | 28 | m_axisY(0) |
|
29 | 29 | { |
|
30 | 30 | connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int))); |
|
31 | 31 | connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int))); |
|
32 | 32 | } |
|
33 | 33 | |
|
34 | 34 | void DeclarativeLineSeries::handleCountChanged(int index) |
|
35 | 35 | { |
|
36 | 36 | Q_UNUSED(index) |
|
37 | 37 | emit countChanged(points().count()); |
|
38 | 38 | } |
|
39 | 39 | |
|
40 | 40 | qreal DeclarativeLineSeries::width() const |
|
41 | 41 | { |
|
42 | 42 | return pen().widthF(); |
|
43 | 43 | } |
|
44 | 44 | |
|
45 | 45 | void DeclarativeLineSeries::setWidth(qreal width) |
|
46 | 46 | { |
|
47 | 47 | if (width != pen().widthF()) { |
|
48 | 48 | QPen p = pen(); |
|
49 | 49 | p.setWidthF(width); |
|
50 | 50 | setPen(p); |
|
51 | 51 | emit widthChanged(width); |
|
52 | 52 | } |
|
53 | 53 | } |
|
54 | 54 | |
|
55 | 55 | Qt::PenStyle DeclarativeLineSeries::style() const |
|
56 | 56 | { |
|
57 | 57 | return pen().style(); |
|
58 | 58 | } |
|
59 | 59 | |
|
60 | 60 | void DeclarativeLineSeries::setStyle(Qt::PenStyle style) |
|
61 | 61 | { |
|
62 | 62 | if (style != pen().style()) { |
|
63 | 63 | QPen p = pen(); |
|
64 | 64 | p.setStyle(style); |
|
65 | 65 | setPen(p); |
|
66 | 66 | emit styleChanged(style); |
|
67 | 67 | } |
|
68 | 68 | } |
|
69 | 69 | |
|
70 | 70 | Qt::PenCapStyle DeclarativeLineSeries::capStyle() const |
|
71 | 71 | { |
|
72 | 72 | return pen().capStyle(); |
|
73 | 73 | } |
|
74 | 74 | |
|
75 | 75 | void DeclarativeLineSeries::setCapStyle(Qt::PenCapStyle capStyle) |
|
76 | 76 | { |
|
77 | 77 | if (capStyle != pen().capStyle()) { |
|
78 | 78 | QPen p = pen(); |
|
79 | 79 | p.setCapStyle(capStyle); |
|
80 | 80 | setPen(p); |
|
81 | 81 | emit capStyleChanged(capStyle); |
|
82 | 82 | } |
|
83 | 83 | } |
|
84 | 84 | |
|
85 | 85 | QDeclarativeListProperty<QObject> DeclarativeLineSeries::declarativeChildren() |
|
86 | 86 | { |
|
87 | 87 | return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren); |
|
88 | 88 | } |
|
89 | 89 | |
|
90 | 90 | void DeclarativeLineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element) |
|
91 | 91 | { |
|
92 | 92 | Q_UNUSED(list) |
|
93 | 93 | Q_UNUSED(element) |
|
94 |
// Empty implementation, child |
|
|
94 | // Empty implementation, children are parsed in componentComplete | |
|
95 | 95 | } |
|
96 | 96 | |
|
97 | 97 | #include "moc_declarativelineseries.cpp" |
|
98 | 98 | |
|
99 | 99 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -1,69 +1,69 | |||
|
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 "declarativescatterseries.h" |
|
22 | 22 | |
|
23 | 23 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
24 | 24 | |
|
25 | 25 | DeclarativeScatterSeries::DeclarativeScatterSeries(QObject *parent) : |
|
26 | 26 | QScatterSeries(parent), |
|
27 | 27 | m_axisX(0), |
|
28 | 28 | m_axisY(0) |
|
29 | 29 | { |
|
30 | 30 | connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int))); |
|
31 | 31 | connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int))); |
|
32 | 32 | } |
|
33 | 33 | |
|
34 | 34 | void DeclarativeScatterSeries::handleCountChanged(int index) |
|
35 | 35 | { |
|
36 | 36 | Q_UNUSED(index) |
|
37 | 37 | emit countChanged(QScatterSeries::count()); |
|
38 | 38 | } |
|
39 | 39 | |
|
40 | 40 | qreal DeclarativeScatterSeries::borderWidth() const |
|
41 | 41 | { |
|
42 | 42 | return pen().widthF(); |
|
43 | 43 | } |
|
44 | 44 | |
|
45 | 45 | void DeclarativeScatterSeries::setBorderWidth(qreal width) |
|
46 | 46 | { |
|
47 | 47 | if (width != pen().widthF()) { |
|
48 | 48 | QPen p = pen(); |
|
49 | 49 | p.setWidthF(width); |
|
50 | 50 | setPen(p); |
|
51 | 51 | emit borderWidthChanged(width); |
|
52 | 52 | } |
|
53 | 53 | } |
|
54 | 54 | |
|
55 | 55 | QDeclarativeListProperty<QObject> DeclarativeScatterSeries::declarativeChildren() |
|
56 | 56 | { |
|
57 | 57 | return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren); |
|
58 | 58 | } |
|
59 | 59 | |
|
60 | 60 | void DeclarativeScatterSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element) |
|
61 | 61 | { |
|
62 | 62 | Q_UNUSED(list) |
|
63 | 63 | Q_UNUSED(element) |
|
64 |
// Empty implementation, child |
|
|
64 | // Empty implementation, children are parsed in componentComplete | |
|
65 | 65 | } |
|
66 | 66 | |
|
67 | 67 | #include "moc_declarativescatterseries.cpp" |
|
68 | 68 | |
|
69 | 69 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -1,99 +1,99 | |||
|
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 "declarativesplineseries.h" |
|
22 | 22 | |
|
23 | 23 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
24 | 24 | |
|
25 | 25 | DeclarativeSplineSeries::DeclarativeSplineSeries(QObject *parent) : |
|
26 | 26 | QSplineSeries(parent), |
|
27 | 27 | m_axisX(0), |
|
28 | 28 | m_axisY(0) |
|
29 | 29 | { |
|
30 | 30 | connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int))); |
|
31 | 31 | connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int))); |
|
32 | 32 | } |
|
33 | 33 | |
|
34 | 34 | void DeclarativeSplineSeries::handleCountChanged(int index) |
|
35 | 35 | { |
|
36 | 36 | Q_UNUSED(index) |
|
37 | 37 | emit countChanged(points().count()); |
|
38 | 38 | } |
|
39 | 39 | |
|
40 | 40 | qreal DeclarativeSplineSeries::width() const |
|
41 | 41 | { |
|
42 | 42 | return pen().widthF(); |
|
43 | 43 | } |
|
44 | 44 | |
|
45 | 45 | void DeclarativeSplineSeries::setWidth(qreal width) |
|
46 | 46 | { |
|
47 | 47 | if (width != pen().widthF()) { |
|
48 | 48 | QPen p = pen(); |
|
49 | 49 | p.setWidthF(width); |
|
50 | 50 | setPen(p); |
|
51 | 51 | emit widthChanged(width); |
|
52 | 52 | } |
|
53 | 53 | } |
|
54 | 54 | |
|
55 | 55 | Qt::PenStyle DeclarativeSplineSeries::style() const |
|
56 | 56 | { |
|
57 | 57 | return pen().style(); |
|
58 | 58 | } |
|
59 | 59 | |
|
60 | 60 | void DeclarativeSplineSeries::setStyle(Qt::PenStyle style) |
|
61 | 61 | { |
|
62 | 62 | if (style != pen().style()) { |
|
63 | 63 | QPen p = pen(); |
|
64 | 64 | p.setStyle(style); |
|
65 | 65 | setPen(p); |
|
66 | 66 | emit styleChanged(style); |
|
67 | 67 | } |
|
68 | 68 | } |
|
69 | 69 | |
|
70 | 70 | Qt::PenCapStyle DeclarativeSplineSeries::capStyle() const |
|
71 | 71 | { |
|
72 | 72 | return pen().capStyle(); |
|
73 | 73 | } |
|
74 | 74 | |
|
75 | 75 | void DeclarativeSplineSeries::setCapStyle(Qt::PenCapStyle capStyle) |
|
76 | 76 | { |
|
77 | 77 | if (capStyle != pen().capStyle()) { |
|
78 | 78 | QPen p = pen(); |
|
79 | 79 | p.setCapStyle(capStyle); |
|
80 | 80 | setPen(p); |
|
81 | 81 | emit capStyleChanged(capStyle); |
|
82 | 82 | } |
|
83 | 83 | } |
|
84 | 84 | |
|
85 | 85 | QDeclarativeListProperty<QObject> DeclarativeSplineSeries::declarativeChildren() |
|
86 | 86 | { |
|
87 | 87 | return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren); |
|
88 | 88 | } |
|
89 | 89 | |
|
90 | 90 | void DeclarativeSplineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element) |
|
91 | 91 | { |
|
92 | 92 | Q_UNUSED(list) |
|
93 | 93 | Q_UNUSED(element) |
|
94 |
// Empty implementation, child |
|
|
94 | // Empty implementation, children are parsed in componentComplete | |
|
95 | 95 | } |
|
96 | 96 | |
|
97 | 97 | #include "moc_declarativesplineseries.cpp" |
|
98 | 98 | |
|
99 | 99 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -1,638 +1,638 | |||
|
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 <qchart.h> |
|
24 | 24 | #include <qpieseries.h> |
|
25 | 25 | #include <qpieslice.h> |
|
26 | 26 | #include <qpiemodelmapper.h> |
|
27 | 27 | #include <QStandardItemModel> |
|
28 | 28 | #include <tst_definitions.h> |
|
29 | 29 | |
|
30 | 30 | QTCOMMERCIALCHART_USE_NAMESPACE |
|
31 | 31 | |
|
32 | 32 | Q_DECLARE_METATYPE(QPieSlice*) |
|
33 | 33 | Q_DECLARE_METATYPE(QList<QPieSlice*>) |
|
34 | 34 | |
|
35 | 35 | class tst_qpieseries : public QObject |
|
36 | 36 | { |
|
37 | 37 | Q_OBJECT |
|
38 | 38 | |
|
39 | 39 | public slots: |
|
40 | 40 | void initTestCase(); |
|
41 | 41 | void cleanupTestCase(); |
|
42 | 42 | void init(); |
|
43 | 43 | void cleanup(); |
|
44 | 44 | |
|
45 | 45 | private slots: |
|
46 | 46 | void properties(); |
|
47 | 47 | void append(); |
|
48 | 48 | void appendAnimated(); |
|
49 | 49 | void insert(); |
|
50 | 50 | void insertAnimated(); |
|
51 | 51 | void remove(); |
|
52 | 52 | void removeAnimated(); |
|
53 | 53 | void take(); |
|
54 | 54 | void takeAnimated(); |
|
55 | 55 | void calculatedValues(); |
|
56 | 56 | void clickedSignal(); |
|
57 | 57 | void hoverSignal(); |
|
58 | 58 | void sliceSeries(); |
|
59 | 59 | void destruction(); |
|
60 | 60 | |
|
61 | 61 | private: |
|
62 | 62 | void verifyCalculatedData(const QPieSeries &series, bool *ok); |
|
63 | 63 | |
|
64 | 64 | private: |
|
65 | 65 | QChartView *m_view; |
|
66 | 66 | QPieSeries *m_series; |
|
67 | 67 | }; |
|
68 | 68 | |
|
69 | 69 | void tst_qpieseries::initTestCase() |
|
70 | 70 | { |
|
71 | 71 | qRegisterMetaType<QPieSlice*>("QPieSlice*"); |
|
72 | 72 | qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>"); |
|
73 | 73 | } |
|
74 | 74 | |
|
75 | 75 | void tst_qpieseries::cleanupTestCase() |
|
76 | 76 | { |
|
77 | 77 | } |
|
78 | 78 | |
|
79 | 79 | void tst_qpieseries::init() |
|
80 | 80 | { |
|
81 | 81 | m_view = new QChartView(); |
|
82 | 82 | m_series = new QPieSeries(m_view); |
|
83 | 83 | m_view->show(); |
|
84 | 84 | QTest::qWaitForWindowShown(m_view); |
|
85 | 85 | |
|
86 | 86 | } |
|
87 | 87 | |
|
88 | 88 | void tst_qpieseries::cleanup() |
|
89 | 89 | { |
|
90 | 90 | delete m_view; |
|
91 | 91 | m_view = 0; |
|
92 | 92 | m_series = 0; |
|
93 | 93 | } |
|
94 | 94 | |
|
95 | 95 | void tst_qpieseries::properties() |
|
96 | 96 | { |
|
97 | 97 | QSignalSpy countSpy(m_series, SIGNAL(countChanged())); |
|
98 | 98 | QSignalSpy sumSpy(m_series, SIGNAL(sumChanged())); |
|
99 | 99 | |
|
100 | 100 | QVERIFY(m_series->type() == QAbstractSeries::SeriesTypePie); |
|
101 | 101 | QVERIFY(m_series->count() == 0); |
|
102 | 102 | QVERIFY(m_series->isEmpty()); |
|
103 | 103 | QCOMPARE(m_series->sum(), 0.0); |
|
104 | 104 | QCOMPARE(m_series->horizontalPosition(), 0.5); |
|
105 | 105 | QCOMPARE(m_series->verticalPosition(), 0.5); |
|
106 | 106 | QCOMPARE(m_series->pieSize(), 0.7); |
|
107 | 107 | QCOMPARE(m_series->pieStartAngle(), 0.0); |
|
108 | 108 | QCOMPARE(m_series->pieEndAngle(), 360.0); |
|
109 | 109 | |
|
110 | 110 | m_series->append("s1", 1); |
|
111 | 111 | m_series->append("s2", 1); |
|
112 | 112 | m_series->append("s3", 1); |
|
113 | 113 | m_series->insert(1, new QPieSlice("s4", 1)); |
|
114 | 114 | m_series->remove(m_series->slices().first()); |
|
115 | 115 | QCOMPARE(m_series->count(), 3); |
|
116 | 116 | QCOMPARE(m_series->sum(), 3.0); |
|
117 | 117 | m_series->clear(); |
|
118 | 118 | QCOMPARE(m_series->count(), 0); |
|
119 | 119 | QCOMPARE(m_series->sum(), 0.0); |
|
120 | 120 | QCOMPARE(countSpy.count(), 6); |
|
121 | 121 | QCOMPARE(sumSpy.count(), 6); |
|
122 | 122 | |
|
123 | 123 | m_series->setPieSize(-1.0); |
|
124 | 124 | QCOMPARE(m_series->pieSize(), 0.0); |
|
125 | 125 | m_series->setPieSize(0.0); |
|
126 | 126 | m_series->setPieSize(0.9); |
|
127 | 127 | m_series->setPieSize(2.0); |
|
128 | 128 | QCOMPARE(m_series->pieSize(), 1.0); |
|
129 | 129 | |
|
130 | 130 | m_series->setPieSize(0.7); |
|
131 | 131 | QCOMPARE(m_series->pieSize(), 0.7); |
|
132 | 132 | |
|
133 | 133 | m_series->setHoleSize(-1.0); |
|
134 | 134 | QCOMPARE(m_series->holeSize(), 0.0); |
|
135 | 135 | m_series->setHoleSize(0.5); |
|
136 | 136 | QCOMPARE(m_series->holeSize(), 0.5); |
|
137 | 137 | |
|
138 | 138 | m_series->setHoleSize(0.8); |
|
139 | 139 | QCOMPARE(m_series->holeSize(), 0.8); |
|
140 | 140 | QCOMPARE(m_series->pieSize(), 0.8); |
|
141 | 141 | |
|
142 | 142 | m_series->setPieSize(0.4); |
|
143 | 143 | QCOMPARE(m_series->pieSize(), 0.4); |
|
144 | 144 | QCOMPARE(m_series->holeSize(), 0.4); |
|
145 | 145 | |
|
146 | 146 | m_series->setPieStartAngle(0); |
|
147 | 147 | m_series->setPieStartAngle(-180); |
|
148 | 148 | m_series->setPieStartAngle(180); |
|
149 | 149 | QCOMPARE(m_series->pieStartAngle(), 180.0); |
|
150 | 150 | |
|
151 | 151 | m_series->setPieEndAngle(360); |
|
152 | 152 | m_series->setPieEndAngle(-180); |
|
153 | 153 | m_series->setPieEndAngle(180); |
|
154 | 154 | QCOMPARE(m_series->pieEndAngle(), 180.0); |
|
155 | 155 | |
|
156 | 156 | m_series->setHorizontalPosition(0.5); |
|
157 | 157 | m_series->setHorizontalPosition(-1.0); |
|
158 | 158 | QCOMPARE(m_series->horizontalPosition(), 0.0); |
|
159 | 159 | m_series->setHorizontalPosition(1.0); |
|
160 | 160 | m_series->setHorizontalPosition(2.0); |
|
161 | 161 | QCOMPARE(m_series->horizontalPosition(), 1.0); |
|
162 | 162 | |
|
163 | 163 | m_series->setVerticalPosition(0.5); |
|
164 | 164 | m_series->setVerticalPosition(-1.0); |
|
165 | 165 | QCOMPARE(m_series->verticalPosition(), 0.0); |
|
166 | 166 | m_series->setVerticalPosition(1.0); |
|
167 | 167 | m_series->setVerticalPosition(2.0); |
|
168 | 168 | QCOMPARE(m_series->verticalPosition(), 1.0); |
|
169 | 169 | } |
|
170 | 170 | |
|
171 | 171 | void tst_qpieseries::append() |
|
172 | 172 | { |
|
173 | 173 | m_view->chart()->addSeries(m_series); |
|
174 | 174 | QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>))); |
|
175 | 175 | |
|
176 | 176 | // append pointer |
|
177 | 177 | QPieSlice *slice1 = 0; |
|
178 | 178 | QVERIFY(!m_series->append(slice1)); |
|
179 | 179 | slice1 = new QPieSlice("slice 1", 1); |
|
180 | 180 | QVERIFY(m_series->append(slice1)); |
|
181 | 181 | QVERIFY(!m_series->append(slice1)); |
|
182 | 182 | QCOMPARE(m_series->count(), 1); |
|
183 | 183 | QCOMPARE(addedSpy.count(), 1); |
|
184 | 184 | QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0)); |
|
185 | 185 | QCOMPARE(added.count(), 1); |
|
186 | 186 | QCOMPARE(added.first(), slice1); |
|
187 | 187 | |
|
188 | 188 | // try to append same slice to another series |
|
189 | 189 | QPieSeries series2; |
|
190 | 190 | QVERIFY(!series2.append(slice1)); |
|
191 | 191 | |
|
192 | 192 | // append pointer list |
|
193 | 193 | QList<QPieSlice *> list; |
|
194 | 194 | QVERIFY(!m_series->append(list)); |
|
195 | 195 | list << (QPieSlice *) 0; |
|
196 | 196 | QVERIFY(!m_series->append(list)); |
|
197 | 197 | list.clear(); |
|
198 | 198 | list << new QPieSlice("slice 2", 2); |
|
199 | 199 | list << new QPieSlice("slice 3", 3); |
|
200 | 200 | QVERIFY(m_series->append(list)); |
|
201 | 201 | QVERIFY(!m_series->append(list)); |
|
202 | 202 | QCOMPARE(m_series->count(), 3); |
|
203 | 203 | QCOMPARE(addedSpy.count(), 2); |
|
204 | 204 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0)); |
|
205 | 205 | QCOMPARE(added.count(), 2); |
|
206 | 206 | QCOMPARE(added, list); |
|
207 | 207 | |
|
208 | 208 | // append operator |
|
209 | 209 | QPieSlice *slice4 = new QPieSlice("slice 4", 4); |
|
210 | 210 | *m_series << slice4; |
|
211 | 211 | *m_series << slice1; // fails because already added |
|
212 | 212 | QCOMPARE(m_series->count(), 4); |
|
213 | 213 | QCOMPARE(addedSpy.count(), 3); |
|
214 | 214 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0)); |
|
215 | 215 | QCOMPARE(added.count(), 1); |
|
216 | 216 | QCOMPARE(added.first(), slice4); |
|
217 | 217 | |
|
218 | 218 | // append with params |
|
219 | 219 | QPieSlice *slice5 = m_series->append("slice 5", 5); |
|
220 | 220 | QVERIFY(slice5 != 0); |
|
221 | 221 | QCOMPARE(slice5->value(), 5.0); |
|
222 | 222 | QCOMPARE(slice5->label(), QString("slice 5")); |
|
223 | 223 | QCOMPARE(m_series->count(), 5); |
|
224 | 224 | QCOMPARE(addedSpy.count(), 4); |
|
225 | 225 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0)); |
|
226 | 226 | QCOMPARE(added.count(), 1); |
|
227 | 227 | QCOMPARE(added.first(), slice5); |
|
228 | 228 | |
|
229 | 229 | // check slices |
|
230 | 230 | QVERIFY(!m_series->isEmpty()); |
|
231 | 231 | for (int i=0; i<m_series->count(); i++) { |
|
232 | 232 | QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1); |
|
233 | 233 | QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1)); |
|
234 | 234 | } |
|
235 | 235 | } |
|
236 | 236 | |
|
237 | 237 | void tst_qpieseries::appendAnimated() |
|
238 | 238 | { |
|
239 | 239 | m_view->chart()->setAnimationOptions(QChart::AllAnimations); |
|
240 | 240 | append(); |
|
241 | 241 | } |
|
242 | 242 | |
|
243 | 243 | void tst_qpieseries::insert() |
|
244 | 244 | { |
|
245 | 245 | m_view->chart()->addSeries(m_series); |
|
246 | 246 | QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>))); |
|
247 | 247 | |
|
248 | 248 | // insert one slice |
|
249 | 249 | QPieSlice *slice1 = 0; |
|
250 | 250 | QVERIFY(!m_series->insert(0, slice1)); |
|
251 | 251 | slice1 = new QPieSlice("slice 1", 1); |
|
252 | 252 | QVERIFY(!m_series->insert(-1, slice1)); |
|
253 | 253 | QVERIFY(!m_series->insert(5, slice1)); |
|
254 | 254 | QVERIFY(m_series->insert(0, slice1)); |
|
255 | 255 | QVERIFY(!m_series->insert(0, slice1)); |
|
256 | 256 | QCOMPARE(m_series->count(), 1); |
|
257 | 257 | QCOMPARE(addedSpy.count(), 1); |
|
258 | 258 | QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0)); |
|
259 | 259 | QCOMPARE(added.count(), 1); |
|
260 | 260 | QCOMPARE(added.first(), slice1); |
|
261 | 261 | |
|
262 | 262 | // try to insert same slice to another series |
|
263 | 263 | QPieSeries series2; |
|
264 | 264 | QVERIFY(!series2.insert(0, slice1)); |
|
265 | 265 | |
|
266 | 266 | // add some more slices |
|
267 | 267 | QPieSlice *slice2 = m_series->append("slice 2", 2); |
|
268 | 268 | QPieSlice *slice4 = m_series->append("slice 4", 4); |
|
269 | 269 | QCOMPARE(m_series->count(), 3); |
|
270 | 270 | QCOMPARE(addedSpy.count(), 3); |
|
271 | 271 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0)); |
|
272 | 272 | QCOMPARE(added.count(), 1); |
|
273 | 273 | QCOMPARE(added.first(), slice2); |
|
274 | 274 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0)); |
|
275 | 275 | QCOMPARE(added.count(), 1); |
|
276 | 276 | QCOMPARE(added.first(), slice4); |
|
277 | 277 | |
|
278 | 278 | // insert between slices |
|
279 | 279 | QPieSlice *slice3 = new QPieSlice("slice 3", 3); |
|
280 | 280 | m_series->insert(2, slice3); |
|
281 | 281 | QCOMPARE(m_series->count(), 4); |
|
282 | 282 | QCOMPARE(addedSpy.count(), 4); |
|
283 | 283 | added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0)); |
|
284 | 284 | QCOMPARE(added.count(), 1); |
|
285 | 285 | QCOMPARE(added.first(), slice3); |
|
286 | 286 | |
|
287 | 287 | // check slices |
|
288 | 288 | for (int i=0; i<m_series->count(); i++) { |
|
289 | 289 | QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1); |
|
290 | 290 | QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1)); |
|
291 | 291 | QVERIFY(m_series->slices().at(i)->parent() == m_series); |
|
292 | 292 | } |
|
293 | 293 | } |
|
294 | 294 | |
|
295 | 295 | void tst_qpieseries::insertAnimated() |
|
296 | 296 | { |
|
297 | 297 | m_view->chart()->setAnimationOptions(QChart::AllAnimations); |
|
298 | 298 | insert(); |
|
299 | 299 | } |
|
300 | 300 | |
|
301 | 301 | void tst_qpieseries::remove() |
|
302 | 302 | { |
|
303 | 303 | m_view->chart()->addSeries(m_series); |
|
304 | 304 | QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>))); |
|
305 | 305 | |
|
306 | 306 | // add some slices |
|
307 | 307 | QPieSlice *slice1 = m_series->append("slice 1", 1); |
|
308 | 308 | QPieSlice *slice2 = m_series->append("slice 2", 2); |
|
309 | 309 | QPieSlice *slice3 = m_series->append("slice 3", 3); |
|
310 | 310 | QSignalSpy spy1(slice1, SIGNAL(destroyed())); |
|
311 | 311 | QSignalSpy spy2(slice2, SIGNAL(destroyed())); |
|
312 | 312 | QSignalSpy spy3(slice3, SIGNAL(destroyed())); |
|
313 | 313 | QCOMPARE(m_series->count(), 3); |
|
314 | 314 | |
|
315 | 315 | // null pointer remove |
|
316 | 316 | QVERIFY(!m_series->remove(0)); |
|
317 | 317 | |
|
318 | 318 | // remove first |
|
319 | 319 | QVERIFY(m_series->remove(slice1)); |
|
320 | 320 | QVERIFY(!m_series->remove(slice1)); |
|
321 | 321 | QCOMPARE(m_series->count(), 2); |
|
322 | 322 | QCOMPARE(m_series->slices().at(0)->label(), slice2->label()); |
|
323 | 323 | QCOMPARE(removedSpy.count(), 1); |
|
324 | 324 | QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0)); |
|
325 | 325 | QCOMPARE(removed.count(), 1); |
|
326 | 326 | QCOMPARE(removed.first(), slice1); |
|
327 | 327 | |
|
328 | 328 | // remove all |
|
329 | 329 | m_series->clear(); |
|
330 | 330 | QVERIFY(m_series->isEmpty()); |
|
331 | 331 | QVERIFY(m_series->slices().isEmpty()); |
|
332 | 332 | QCOMPARE(m_series->count(), 0); |
|
333 | 333 | QCOMPARE(removedSpy.count(), 2); |
|
334 | 334 | removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0)); |
|
335 | 335 | QCOMPARE(removed.count(), 2); |
|
336 | 336 | QCOMPARE(removed.first(), slice2); |
|
337 | 337 | QCOMPARE(removed.last(), slice3); |
|
338 | 338 | |
|
339 | 339 | // check that slices were actually destroyed |
|
340 | 340 | TRY_COMPARE(spy1.count(), 1); |
|
341 | 341 | TRY_COMPARE(spy2.count(), 1); |
|
342 | 342 | TRY_COMPARE(spy3.count(), 1); |
|
343 | 343 | } |
|
344 | 344 | |
|
345 | 345 | void tst_qpieseries::removeAnimated() |
|
346 | 346 | { |
|
347 | 347 | m_view->chart()->setAnimationOptions(QChart::AllAnimations); |
|
348 | 348 | remove(); |
|
349 | 349 | } |
|
350 | 350 | |
|
351 | 351 | void tst_qpieseries::take() |
|
352 | 352 | { |
|
353 | 353 | m_view->chart()->addSeries(m_series); |
|
354 | 354 | QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>))); |
|
355 | 355 | |
|
356 | 356 | // add some slices |
|
357 | 357 | QPieSlice *slice1 = m_series->append("slice 1", 1); |
|
358 | 358 | QPieSlice *slice2 = m_series->append("slice 2", 2); |
|
359 | 359 | m_series->append("slice 3", 3); |
|
360 | 360 | QSignalSpy spy1(slice1, SIGNAL(destroyed())); |
|
361 | 361 | QCOMPARE(m_series->count(), 3); |
|
362 | 362 | |
|
363 | 363 | // null pointer remove |
|
364 | 364 | QVERIFY(!m_series->take(0)); |
|
365 | 365 | |
|
366 | 366 | // take first |
|
367 | 367 | QVERIFY(m_series->take(slice1)); |
|
368 | 368 | TRY_COMPARE(spy1.count(), 0); |
|
369 | 369 | QVERIFY(slice1->parent() == m_series); // series is still the parent object |
|
370 | 370 | QVERIFY(!m_series->take(slice1)); |
|
371 | 371 | QCOMPARE(m_series->count(), 2); |
|
372 | 372 | QCOMPARE(m_series->slices().at(0)->label(), slice2->label()); |
|
373 | 373 | QCOMPARE(removedSpy.count(), 1); |
|
374 | 374 | QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0)); |
|
375 | 375 | QCOMPARE(removed.count(), 1); |
|
376 | 376 | QCOMPARE(removed.first(), slice1); |
|
377 | 377 | } |
|
378 | 378 | |
|
379 | 379 | void tst_qpieseries::takeAnimated() |
|
380 | 380 | { |
|
381 | 381 | m_view->chart()->setAnimationOptions(QChart::AllAnimations); |
|
382 | 382 | take(); |
|
383 | 383 | } |
|
384 | 384 | |
|
385 | 385 | void tst_qpieseries::calculatedValues() |
|
386 | 386 | { |
|
387 | 387 | m_view->chart()->addSeries(m_series); |
|
388 | 388 | |
|
389 | 389 | QPieSlice *slice1 = new QPieSlice("slice 1", 1); |
|
390 | 390 | QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged())); |
|
391 | 391 | QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged())); |
|
392 | 392 | QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged())); |
|
393 | 393 | |
|
394 | 394 | // add a slice |
|
395 | 395 | m_series->append(slice1); |
|
396 | 396 | bool ok; |
|
397 | 397 | verifyCalculatedData(*m_series, &ok); |
|
398 | 398 | if (!ok) |
|
399 | 399 | return; |
|
400 | 400 | QCOMPARE(percentageSpy.count(), 1); |
|
401 | 401 | QCOMPARE(startAngleSpy.count(), 0); |
|
402 | 402 | QCOMPARE(angleSpanSpy.count(), 1); |
|
403 | 403 | |
|
404 | 404 | // add some more slices |
|
405 | 405 | QList<QPieSlice *> list; |
|
406 | 406 | list << new QPieSlice("slice 2", 2); |
|
407 | 407 | list << new QPieSlice("slice 3", 3); |
|
408 | 408 | m_series->append(list); |
|
409 | 409 | verifyCalculatedData(*m_series, &ok); |
|
410 | 410 | if (!ok) |
|
411 | 411 | return; |
|
412 | 412 | QCOMPARE(percentageSpy.count(), 2); |
|
413 | 413 | QCOMPARE(startAngleSpy.count(), 0); |
|
414 | 414 | QCOMPARE(angleSpanSpy.count(), 2); |
|
415 | 415 | |
|
416 | 416 | // remove a slice |
|
417 | 417 | m_series->remove(list.first()); // remove slice 2 |
|
418 | 418 | verifyCalculatedData(*m_series, &ok); |
|
419 | 419 | if (!ok) |
|
420 | 420 | return; |
|
421 | 421 | QCOMPARE(percentageSpy.count(), 3); |
|
422 | 422 | QCOMPARE(startAngleSpy.count(), 0); |
|
423 | 423 | QCOMPARE(angleSpanSpy.count(), 3); |
|
424 | 424 | |
|
425 | 425 | // insert a slice |
|
426 | 426 | m_series->insert(0, new QPieSlice("Slice 4", 4)); |
|
427 | 427 | verifyCalculatedData(*m_series, &ok); |
|
428 | 428 | if (!ok) |
|
429 | 429 | return; |
|
430 | 430 | QCOMPARE(percentageSpy.count(), 4); |
|
431 | 431 | QCOMPARE(startAngleSpy.count(), 1); |
|
432 | 432 | QCOMPARE(angleSpanSpy.count(), 4); |
|
433 | 433 | |
|
434 | 434 | // modify pie angles |
|
435 | 435 | m_series->setPieStartAngle(-90); |
|
436 | 436 | m_series->setPieEndAngle(90); |
|
437 | 437 | verifyCalculatedData(*m_series, &ok); |
|
438 | 438 | if (!ok) |
|
439 | 439 | return; |
|
440 | 440 | QCOMPARE(percentageSpy.count(), 4); |
|
441 | 441 | QCOMPARE(startAngleSpy.count(), 3); |
|
442 | 442 | QCOMPARE(angleSpanSpy.count(), 6); |
|
443 | 443 | |
|
444 | 444 | // clear all |
|
445 | 445 | m_series->clear(); |
|
446 | 446 | verifyCalculatedData(*m_series, &ok); |
|
447 | 447 | if (!ok) |
|
448 | 448 | return; |
|
449 | 449 | QCOMPARE(percentageSpy.count(), 4); |
|
450 | 450 | QCOMPARE(startAngleSpy.count(), 3); |
|
451 | 451 | QCOMPARE(angleSpanSpy.count(), 6); |
|
452 | 452 | } |
|
453 | 453 | |
|
454 | 454 | void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok) |
|
455 | 455 | { |
|
456 | 456 | *ok = false; |
|
457 | 457 | |
|
458 | 458 | qreal sum = 0; |
|
459 | 459 | foreach (const QPieSlice *slice, series.slices()) |
|
460 | 460 | sum += slice->value(); |
|
461 | 461 | QCOMPARE(series.sum(), sum); |
|
462 | 462 | |
|
463 | 463 | qreal startAngle = series.pieStartAngle(); |
|
464 | 464 | qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle(); |
|
465 | 465 | foreach (const QPieSlice *slice, series.slices()) { |
|
466 | 466 | qreal ratio = slice->value() / sum; |
|
467 | 467 | qreal sliceSpan = pieAngleSpan * ratio; |
|
468 | 468 | QCOMPARE(slice->startAngle(), startAngle); |
|
469 | 469 | QCOMPARE(slice->angleSpan(), sliceSpan); |
|
470 | 470 | QCOMPARE(slice->percentage(), ratio); |
|
471 | 471 | startAngle += sliceSpan; |
|
472 | 472 | } |
|
473 | 473 | |
|
474 | 474 | if (!series.isEmpty()) |
|
475 | 475 | QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle()); |
|
476 | 476 | |
|
477 | 477 | *ok = true; |
|
478 | 478 | } |
|
479 | 479 | |
|
480 | 480 | |
|
481 | 481 | void tst_qpieseries::clickedSignal() |
|
482 | 482 | { |
|
483 | 483 | // add some slices |
|
484 | 484 | QPieSlice *s1 = m_series->append("slice 1", 1); |
|
485 | 485 | QPieSlice *s2 = m_series->append("slice 2", 1); |
|
486 | 486 | QPieSlice *s3 = m_series->append("slice 3", 1); |
|
487 | 487 | QPieSlice *s4 = m_series->append("slice 4", 1); |
|
488 | 488 | QSignalSpy clickSpy(m_series, SIGNAL(clicked(QPieSlice*))); |
|
489 | 489 | |
|
490 | 490 | // add series to the chart |
|
491 | 491 | m_view->chart()->legend()->setVisible(false); |
|
492 | 492 | m_view->resize(200, 200); |
|
493 | 493 | m_view->chart()->addSeries(m_series); |
|
494 | 494 | m_view->show(); |
|
495 | 495 | QTest::qWaitForWindowShown(m_view); |
|
496 | 496 | |
|
497 |
// if you d |
|
|
497 | // if you divide the chart in four equal tiles these | |
|
498 | 498 | // are the center points of those tiles |
|
499 | 499 | QPoint p1(90.25, 90); |
|
500 | 500 | QPoint p2(150, 90); |
|
501 | 501 | QPoint p3(90, 150); |
|
502 | 502 | QPoint p4(150, 150); |
|
503 | 503 | |
|
504 | 504 | QPoint center(120, 120); |
|
505 | 505 | |
|
506 | 506 | m_series->setPieSize(1.0); |
|
507 | 507 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); |
|
508 | 508 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); |
|
509 | 509 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); |
|
510 | 510 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); |
|
511 | 511 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center); |
|
512 | 512 | TRY_COMPARE(clickSpy.count(), 5); // all hit |
|
513 | 513 | QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4); |
|
514 | 514 | QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1); |
|
515 | 515 | QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3); |
|
516 | 516 | QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2); |
|
517 | 517 | clickSpy.clear(); |
|
518 | 518 | |
|
519 | 519 | m_series->setPieSize(0.5); |
|
520 | 520 | m_series->setVerticalPosition(0.25); |
|
521 | 521 | m_series->setHorizontalPosition(0.25); |
|
522 | 522 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); // hits |
|
523 | 523 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); |
|
524 | 524 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); |
|
525 | 525 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); |
|
526 | 526 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center); |
|
527 | 527 | TRY_COMPARE(clickSpy.count(), 1); |
|
528 | 528 | clickSpy.clear(); |
|
529 | 529 | |
|
530 | 530 | m_series->setVerticalPosition(0.25); |
|
531 | 531 | m_series->setHorizontalPosition(0.75); |
|
532 | 532 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); |
|
533 | 533 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); // hits |
|
534 | 534 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); |
|
535 | 535 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); |
|
536 | 536 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center); |
|
537 | 537 | TRY_COMPARE(clickSpy.count(), 1); |
|
538 | 538 | clickSpy.clear(); |
|
539 | 539 | |
|
540 | 540 | m_series->setVerticalPosition(0.75); |
|
541 | 541 | m_series->setHorizontalPosition(0.25); |
|
542 | 542 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); |
|
543 | 543 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); |
|
544 | 544 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); // hits |
|
545 | 545 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); |
|
546 | 546 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center); |
|
547 | 547 | TRY_COMPARE(clickSpy.count(), 1); |
|
548 | 548 | clickSpy.clear(); |
|
549 | 549 | |
|
550 | 550 | m_series->setVerticalPosition(0.75); |
|
551 | 551 | m_series->setHorizontalPosition(0.75); |
|
552 | 552 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); |
|
553 | 553 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); |
|
554 | 554 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); |
|
555 | 555 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); // hits |
|
556 | 556 | QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center); |
|
557 | 557 | TRY_COMPARE(clickSpy.count(), 1); |
|
558 | 558 | clickSpy.clear(); |
|
559 | 559 | } |
|
560 | 560 | |
|
561 | 561 | void tst_qpieseries::hoverSignal() |
|
562 | 562 | { |
|
563 | 563 | // add some slices |
|
564 | 564 | m_series->setPieSize(1.0); |
|
565 | 565 | QPieSlice *s1 = m_series->append("slice 1", 1); |
|
566 | 566 | m_series->append("slice 2", 2); |
|
567 | 567 | m_series->append("slice 3", 3); |
|
568 | 568 | |
|
569 | 569 | // add series to the chart |
|
570 | 570 | m_view->chart()->legend()->setVisible(false); |
|
571 | 571 | m_view->resize(200, 200); |
|
572 | 572 | m_view->chart()->addSeries(m_series); |
|
573 | 573 | m_view->show(); |
|
574 | 574 | QTest::qWaitForWindowShown(m_view); |
|
575 | 575 | |
|
576 | 576 | // first move to right top corner |
|
577 | 577 | QTest::mouseMove(m_view->viewport(), QPoint(200, 0)); |
|
578 | 578 | QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); |
|
579 | 579 | |
|
580 | 580 | // move inside the slice |
|
581 | 581 | // pie rectangle: QRectF(60,60 121x121) |
|
582 | 582 | QSignalSpy hoverSpy(m_series, SIGNAL(hovered(QPieSlice*,bool))); |
|
583 | 583 | QTest::mouseMove(m_view->viewport(), QPoint(139, 85)); |
|
584 | 584 | TRY_COMPARE(hoverSpy.count(), 1); |
|
585 | 585 | QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1); |
|
586 | 586 | QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true); |
|
587 | 587 | |
|
588 | 588 | // move outside the slice |
|
589 | 589 | QTest::mouseMove(m_view->viewport(), QPoint(200, 0)); |
|
590 | 590 | TRY_COMPARE(hoverSpy.count(), 2); |
|
591 | 591 | QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1); |
|
592 | 592 | QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false); |
|
593 | 593 | } |
|
594 | 594 | |
|
595 | 595 | void tst_qpieseries::sliceSeries() |
|
596 | 596 | { |
|
597 | 597 | QPieSlice *slice = new QPieSlice(); |
|
598 | 598 | QVERIFY(!slice->series()); |
|
599 | 599 | delete slice; |
|
600 | 600 | |
|
601 | 601 | slice = new QPieSlice(m_series); |
|
602 | 602 | QVERIFY(!slice->series()); |
|
603 | 603 | |
|
604 | 604 | m_series->append(slice); |
|
605 | 605 | QCOMPARE(slice->series(), m_series); |
|
606 | 606 | |
|
607 | 607 | slice = new QPieSlice(); |
|
608 | 608 | m_series->insert(0, slice); |
|
609 | 609 | QCOMPARE(slice->series(), m_series); |
|
610 | 610 | |
|
611 | 611 | m_series->take(slice); |
|
612 | 612 | QCOMPARE(slice->series(), (QPieSeries*) 0); |
|
613 | 613 | } |
|
614 | 614 | |
|
615 | 615 | void tst_qpieseries::destruction() |
|
616 | 616 | { |
|
617 | 617 | // add some slices |
|
618 | 618 | QPieSlice *slice1 = m_series->append("slice 1", 1); |
|
619 | 619 | QPieSlice *slice2 = m_series->append("slice 2", 2); |
|
620 | 620 | QPieSlice *slice3 = m_series->append("slice 3", 3); |
|
621 | 621 | QSignalSpy spy1(slice1, SIGNAL(destroyed())); |
|
622 | 622 | QSignalSpy spy2(slice2, SIGNAL(destroyed())); |
|
623 | 623 | QSignalSpy spy3(slice3, SIGNAL(destroyed())); |
|
624 | 624 | |
|
625 | 625 | // destroy series |
|
626 | 626 | delete m_series; |
|
627 | 627 | m_series = 0; |
|
628 | 628 | |
|
629 | 629 | // check that series has destroyed its slices |
|
630 | 630 | QCOMPARE(spy1.count(), 1); |
|
631 | 631 | QCOMPARE(spy2.count(), 1); |
|
632 | 632 | QCOMPARE(spy3.count(), 1); |
|
633 | 633 | } |
|
634 | 634 | |
|
635 | 635 | QTEST_MAIN(tst_qpieseries) |
|
636 | 636 | |
|
637 | 637 | #include "tst_qpieseries.moc" |
|
638 | 638 |
General Comments 0
You need to be logged in to leave comments.
Login now