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

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

Axis refactoring to support better barcharts
Michal Klocek -
r502:c37a1568cc38
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,78 +1,78
1 #include <QApplication>
1 #include <QApplication>
2 #include <QMainWindow>
2 #include <QMainWindow>
3 #include <qchartview.h>
3 #include <qchartview.h>
4 #include <qlineseries.h>
4 #include <qlineseries.h>
5 #include <qchart.h>
5 #include <qchart.h>
6 #include <qchartaxis.h>
6 #include <qchartaxis.h>
7 #include <qchartaxiscategories.h>
7 #include <qchartaxiscategories.h>
8 #include <cmath>
8 #include <cmath>
9
9
10 QTCOMMERCIALCHART_USE_NAMESPACE
10 QTCOMMERCIALCHART_USE_NAMESPACE
11
11
12 #define PI 3.14159265358979
12 #define PI 3.14159265358979
13
13
14 int main(int argc, char *argv[])
14 int main(int argc, char *argv[])
15 {
15 {
16 QApplication a(argc, argv);
16 QApplication a(argc, argv);
17
17
18 QMainWindow window;
18 QMainWindow window;
19
19
20 QLineSeries* series0 = new QLineSeries();
20 QLineSeries* series0 = new QLineSeries();
21 QPen blue(Qt::blue);
21 QPen blue(Qt::blue);
22 blue.setWidth(3);
22 blue.setWidth(3);
23 series0->setPen(blue);
23 series0->setPen(blue);
24 QLineSeries* series1 = new QLineSeries();
24 QLineSeries* series1 = new QLineSeries();
25 QPen red(Qt::red);
25 QPen red(Qt::red);
26 red.setWidth(3);
26 red.setWidth(3);
27 series1->setPen(red);
27 series1->setPen(red);
28
28
29 int numPoints = 100;
29 int numPoints = 100;
30
30
31 for (int x = 0; x <= numPoints; ++x) {
31 for (int x = 0; x <= numPoints; ++x) {
32 series0->add(x, fabs(sin(PI/50*x)*100));
32 series0->add(x, fabs(sin(PI/50*x)*100));
33 series1->add(x, fabs(cos(PI/50*x)*100));
33 series1->add(x, fabs(cos(PI/50*x)*100));
34 }
34 }
35
35
36 QChartView* chartView = new QChartView(&window);
36 QChartView* chartView = new QChartView(&window);
37
37
38 chartView->setRenderHint(QPainter::Antialiasing);
38 chartView->setRenderHint(QPainter::Antialiasing);
39 chartView->setChartTitle("This is custom axis chart example");
39 chartView->setChartTitle("This is custom axis chart example");
40 chartView->addSeries(series0);
40 chartView->addSeries(series0);
41 chartView->addSeries(series1);
41 chartView->addSeries(series1);
42
42
43 QLinearGradient backgroundGradient;
43 QLinearGradient backgroundGradient;
44 backgroundGradient.setColorAt(0.0, Qt::white);
44 backgroundGradient.setColorAt(0.0, Qt::white);
45 backgroundGradient.setColorAt(1.0, QRgb(0xffff80));
45 backgroundGradient.setColorAt(1.0, QRgb(0xffff80));
46 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
46 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
47 chartView->setChartBackgroundBrush(backgroundGradient);
47 chartView->setChartBackgroundBrush(backgroundGradient);
48
48
49 QChartAxis* axisX = chartView->axisX();
49 QChartAxis* axisX = chartView->axisX();
50 axisX->setLabelsAngle(45);
50 axisX->setLabelsAngle(45);
51 axisX->setGridPen(Qt::DashLine);
51 axisX->setGridPen(Qt::DashLine);
52
52
53 QChartAxisCategories *categoriesX = axisX->categories();
53 QChartAxisCategories* categoriesX = axisX->categories();
54 categoriesX->insert(0,"low");
54 categoriesX->insert(0,"low");
55 categoriesX->insert(50,"medium");
55 categoriesX->insert(50,"medium");
56 categoriesX->insert(100,"High");
56 categoriesX->insert(100,"High");
57
57
58 axisX->setMin(-10);
58 axisX->setMin(-10);
59 axisX->setMax(2200);
59 axisX->setMax(2200);
60
60
61 QChartAxis* axisY = chartView->axisY();
61 QChartAxis* axisY = chartView->axisY();
62 axisY->setLabelsAngle(45);
62 axisY->setLabelsAngle(45);
63 axisY->setShadesBrush(Qt::yellow);
63 axisY->setShadesBrush(Qt::yellow);
64
64
65 QChartAxisCategories *categoriesY = axisY->categories();
65 QChartAxisCategories* categoriesY = axisY->categories();
66 categoriesY->insert(0,"low");
66 categoriesY->insert(0,"low");
67 categoriesY->insert(50,"medium");
67 categoriesY->insert(50,"medium");
68 categoriesY->insert(100,"High");
68 categoriesY->insert(100,"High");
69
69
70 axisY->setMin(-10);
70 axisY->setMin(-10);
71 axisY->setMax(200);
71 axisY->setMax(200);
72
72
73 window.setCentralWidget(chartView);
73 window.setCentralWidget(chartView);
74 window.resize(400, 300);
74 window.resize(400, 300);
75 window.show();
75 window.show();
76
76
77 return a.exec();
77 return a.exec();
78 }
78 }
Show file before | Show file after | Hide comments
@@ -1,77 +1,75
1 #include "axisanimationitem_p.h"
1 #include "axisanimationitem_p.h"
2 #include <QTimer>
2 #include <QTimer>
3
3
4 Q_DECLARE_METATYPE(QVector<qreal>)
4 Q_DECLARE_METATYPE(QVector<qreal>)
5
5
6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
7
7
8 const static int duration = 500;
8 const static int duration = 500;
9
9
10 AxisAnimationItem::AxisAnimationItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
10 AxisAnimationItem::AxisAnimationItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
11 AxisItem(axis,type,parent),
11 AxisItem(axis,type,parent),
12 m_animation(new AxisAnimator(this,this))
12 m_animation(new AxisAnimator(this,this))
13 {
13 {
14 }
14 }
15
15
16 AxisAnimationItem::~AxisAnimationItem()
16 AxisAnimationItem::~AxisAnimationItem()
17 {
17 {
18 }
18 }
19
19
20 void AxisAnimationItem::updateItem()
20 void AxisAnimationItem::updateLayout(QVector<qreal>& newLayout)
21 {
21 {
22 QVector<qreal> oldLayout = layout();
22 QVector<qreal> oldLayout = layout();
23 AxisItem::updateItem();
24 QVector<qreal> newLayout = layout();
25
23
26 if(newLayout.count()==0) return;
24 if(newLayout.count()==0) return;
27 oldLayout.resize(newLayout.size());
25 oldLayout.resize(newLayout.size());
28
26
29 if(m_animation->state()!=QAbstractAnimation::Stopped){
27 if(m_animation->state()!=QAbstractAnimation::Stopped){
30 m_animation->stop();
28 m_animation->stop();
31 }
29 }
32
30
33 m_animation->setDuration(duration);
31 m_animation->setDuration(duration);
34 m_animation->setEasingCurve(QEasingCurve::InOutBack);
32 m_animation->setEasingCurve(QEasingCurve::InOutBack);
35 m_animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
33 m_animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
36 m_animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
34 m_animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
37 QTimer::singleShot(0,m_animation,SLOT(start()));
35 QTimer::singleShot(0,m_animation,SLOT(start()));
38 }
36 }
39
37
40 void AxisAnimationItem::setLabelsAngle(int angle)
38 void AxisAnimationItem::setLabelsAngle(int angle)
41 {
39 {
42 AxisItem::setLabelsAngle(angle);
40 AxisItem::setLabelsAngle(angle);
43 }
41 }
44
42
45 AxisAnimator::AxisAnimator(AxisItem *axis,QObject *parent): QVariantAnimation(parent),
43 AxisAnimator::AxisAnimator(AxisItem *axis,QObject *parent): QVariantAnimation(parent),
46 m_axis(axis)
44 m_axis(axis)
47 {
45 {
48 }
46 }
49
47
50 AxisAnimator::~AxisAnimator()
48 AxisAnimator::~AxisAnimator()
51 {
49 {
52 }
50 }
53
51
54 QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
52 QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
55 {
53 {
56 QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
54 QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
57 QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
55 QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
58 QVector<qreal> result;
56 QVector<qreal> result;
59 Q_ASSERT(startVector.count() == endVecotr.count());
57 Q_ASSERT(startVector.count() == endVecotr.count());
60
58
61 for(int i =0 ;i< startVector.count();i++){
59 for(int i =0 ;i< startVector.count();i++){
62 qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
60 qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
63 result << value;
61 result << value;
64 }
62 }
65 return qVariantFromValue(result);
63 return qVariantFromValue(result);
66 }
64 }
67
65
68
66
69 void AxisAnimator::updateCurrentValue (const QVariant & value )
67 void AxisAnimator::updateCurrentValue (const QVariant & value )
70 {
68 {
71 QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
69 QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
72 m_axis->setLayout(vector);
70 m_axis->setLayout(vector);
73 }
71 }
74
72
75 #include "moc_axisanimationitem_p.cpp"
73 #include "moc_axisanimationitem_p.cpp"
76
74
77 QTCOMMERCIALCHART_END_NAMESPACE
75 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,45 +1,46
1 #ifndef AXISANIMATIONITEM_H_
1 #ifndef AXISANIMATIONITEM_H_
2 #define AXISANIMATIONITEM_H_
2 #define AXISANIMATIONITEM_H_
3
3
4 #include "domain_p.h"
4 #include "domain_p.h"
5 #include "axisitem_p.h"
5 #include "axisitem_p.h"
6 #include <QGraphicsItem>
6 #include <QGraphicsItem>
7 #include <QVariantAnimation>
7 #include <QVariantAnimation>
8
8
9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10
10
11 class AxisAnimator;
11 class AxisAnimator;
12
12
13 class AxisAnimationItem : public AxisItem
13 class AxisAnimationItem : public AxisItem
14 {
14 {
15 Q_OBJECT
15 Q_OBJECT
16
16
17 public:
17 public:
18 AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
18 AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
19 ~AxisAnimationItem();
19 ~AxisAnimationItem();
20
20
21 void setLabelsAngle(int angle);
21 void setLabelsAngle(int angle);
22
22
23 protected:
23 protected:
24 virtual void updateItem();
24 virtual void updateLayout(QVector<qreal>& layout);
25
25 private:
26 private:
26 AxisAnimator *m_animation;
27 AxisAnimator *m_animation;
27 };
28 };
28
29
29 class AxisAnimator: public QVariantAnimation
30 class AxisAnimator: public QVariantAnimation
30 {
31 {
31 public:
32 public:
32 AxisAnimator(AxisItem *axis,QObject *parent = 0);
33 AxisAnimator(AxisItem *axis,QObject *parent = 0);
33 ~AxisAnimator();
34 ~AxisAnimator();
34 protected:
35 protected:
35 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
36 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
36 virtual void updateCurrentValue (const QVariant & value );
37 virtual void updateCurrentValue (const QVariant & value );
37 private:
38 private:
38 AxisItem* m_axis;
39 AxisItem* m_axis;
39 };
40 };
40
41
41 QTCOMMERCIALCHART_END_NAMESPACE
42 QTCOMMERCIALCHART_END_NAMESPACE
42
43
43
44
44
45
45 #endif /* AXISITEM_H_ */
46 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,397 +1,416
1 #include "axisitem_p.h"
1 #include "axisitem_p.h"
2 #include "qchartaxis.h"
2 #include "qchartaxis.h"
3 #include "chartpresenter_p.h"
3 #include "chartpresenter_p.h"
4 #include <QPainter>
4 #include <QPainter>
5 #include <QDebug>
5 #include <QDebug>
6
6
7 static int label_padding = 5;
7 static int label_padding = 5;
8
8
9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10
10
11 AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
11 AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
12 ChartItem(parent),
12 ChartItem(parent),
13 m_chartAxis(axis),
13 m_chartAxis(axis),
14 m_type(type),
14 m_type(type),
15 m_labelsAngle(0),
15 m_labelsAngle(0),
16 m_grid(parent),
16 m_grid(parent),
17 m_shades(parent),
17 m_shades(parent),
18 m_labels(parent),
18 m_labels(parent),
19 m_axis(parent)
19 m_axis(parent),
20 m_min(0),
21 m_max(0),
22 m_ticksCount(0)
20 {
23 {
21 //initial initialization
24 //initial initialization
22 m_axis.setZValue(ChartPresenter::AxisZValue);
25 m_axis.setZValue(ChartPresenter::AxisZValue);
23 m_shades.setZValue(ChartPresenter::ShadesZValue);
26 m_shades.setZValue(ChartPresenter::ShadesZValue);
24 m_grid.setZValue(ChartPresenter::GridZValue);
27 m_grid.setZValue(ChartPresenter::GridZValue);
25 setFlags(QGraphicsItem::ItemHasNoContents);
28 setFlags(QGraphicsItem::ItemHasNoContents);
26
29
27 QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
30 QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
28 QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
31 QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
32
33 handleAxisUpdated();
29 }
34 }
30
35
31 AxisItem::~AxisItem()
36 AxisItem::~AxisItem()
32 {
37 {
33 }
38 }
34
39
35 QRectF AxisItem::boundingRect() const
40 QRectF AxisItem::boundingRect() const
36 {
41 {
37 return QRectF();
42 return QRectF();
38 }
43 }
39
44
40 void AxisItem::createItems(int count)
45 void AxisItem::createItems(int count)
41 {
46 {
42 if(m_axis.children().size()==0)
47 if(m_axis.children().size()==0)
43 m_axis.addToGroup(new QGraphicsLineItem());
48 m_axis.addToGroup(new QGraphicsLineItem());
44 for (int i = 0; i < count; ++i) {
49 for (int i = 0; i < count; ++i) {
45 m_grid.addToGroup(new QGraphicsLineItem());
50 m_grid.addToGroup(new QGraphicsLineItem());
46 m_labels.addToGroup(new QGraphicsSimpleTextItem());
51 m_labels.addToGroup(new QGraphicsSimpleTextItem());
47 if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
52 if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
48 m_axis.addToGroup(new QGraphicsLineItem());
53 m_axis.addToGroup(new QGraphicsLineItem());
49 }
54 }
50 }
55 }
51
56
52 void AxisItem::clear(int count)
57 void AxisItem::deleteItems(int count)
53 {
58 {
54 QList<QGraphicsItem *> lines = m_grid.childItems();
59 QList<QGraphicsItem *> lines = m_grid.childItems();
55 QList<QGraphicsItem *> labels = m_labels.childItems();
60 QList<QGraphicsItem *> labels = m_labels.childItems();
56 QList<QGraphicsItem *> shades = m_shades.childItems();
61 QList<QGraphicsItem *> shades = m_shades.childItems();
57 QList<QGraphicsItem *> axis = m_axis.childItems();
62 QList<QGraphicsItem *> axis = m_axis.childItems();
58
63
59 for (int i = 0; i < count; ++i) {
64 for (int i = 0; i < count; ++i) {
60 delete(lines.takeLast());
65 delete(lines.takeLast());
61 delete(labels.takeLast());
66 delete(labels.takeLast());
62 if(lines.size()%2) delete(shades.takeLast());
67 if(lines.size()%2) delete(shades.takeLast());
63 delete(axis.takeLast());
68 delete(axis.takeLast());
64 }
69 }
65 }
70 }
66
71
67 void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
72 void AxisItem::updateLayout(QVector<qreal>& layout)
68 {
73 {
69 Q_UNUSED(painter);
70 Q_UNUSED(option);
71 Q_UNUSED(widget);
72 }
73
74 void AxisItem::updateItem()
75 {
76 QStringList labels = createLabels(m_ticks,m_min,m_max);
77
78 int diff = m_thicksList.size() - labels.size();
79
80 if(diff>0) {
81 clear(diff);
82 }
83 else if(diff<0) {
84 createItems(-diff);
85 }
86
87 if(diff!=0) handleAxisUpdated();
88
89 m_thicksList=labels;
90
91 QVector<qreal> layout = calculateLayout();
92 if(layout.count()==0) return;
93 setLayout(layout);
74 setLayout(layout);
94
95 }
75 }
96
76
97 QStringList AxisItem::createLabels(int ticks, qreal min, qreal max)
77 QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
98 {
78 {
99 Q_ASSERT(max>=min);
79 Q_ASSERT(max>=min);
80 Q_ASSERT(ticks>0);
100
81
101 QStringList labels;
82 QStringList labels;
102
83
103 QChartAxisCategories* categories = m_chartAxis->categories();
84 QChartAxisCategories* categories = m_chartAxis->categories();
104
85
105 for(int i=0; i<= ticks; i++) {
86 for(int i=0; i< ticks; i++) {
106 qreal value = min + (i * (max - min)/ ticks);
87 qreal value = min + (i * (max - min)/ (ticks-1));
107 if(categories->count()==0) {
88 if(categories->count()==0) {
108 labels << QString::number(value);
89 labels << QString::number(value);
109 }
90 }
110 else {
91 else {
111 QString label = categories->label(value);
92 QString label = categories->label(value);
112 labels << label;
93 labels << label;
113 }
94 }
114 }
95 }
96
97
115 return labels;
98 return labels;
116 }
99 }
117
100
118 void AxisItem::setAxisOpacity(qreal opacity)
101 void AxisItem::setAxisOpacity(qreal opacity)
119 {
102 {
120 m_axis.setOpacity(opacity);
103 m_axis.setOpacity(opacity);
121 }
104 }
122
105
123 qreal AxisItem::axisOpacity() const
106 qreal AxisItem::axisOpacity() const
124 {
107 {
125 return m_axis.opacity();
108 return m_axis.opacity();
126 }
109 }
127
110
128 void AxisItem::setGridOpacity(qreal opacity)
111 void AxisItem::setGridOpacity(qreal opacity)
129 {
112 {
130 m_grid.setOpacity(opacity);
113 m_grid.setOpacity(opacity);
131 }
114 }
132
115
133 qreal AxisItem::gridOpacity() const
116 qreal AxisItem::gridOpacity() const
134 {
117 {
135 return m_grid.opacity();
118 return m_grid.opacity();
136 }
119 }
137
120
138 void AxisItem::setLabelsOpacity(qreal opacity)
121 void AxisItem::setLabelsOpacity(qreal opacity)
139 {
122 {
140 m_labels.setOpacity(opacity);
123 m_labels.setOpacity(opacity);
141 }
124 }
142
125
143 qreal AxisItem::labelsOpacity() const
126 qreal AxisItem::labelsOpacity() const
144 {
127 {
145 return m_labels.opacity();
128 return m_labels.opacity();
146 }
129 }
147
130
148 void AxisItem::setShadesOpacity(qreal opacity)
131 void AxisItem::setShadesOpacity(qreal opacity)
149 {
132 {
150 m_shades.setOpacity(opacity);
133 m_shades.setOpacity(opacity);
151 }
134 }
152
135
153 qreal AxisItem::shadesOpacity() const
136 qreal AxisItem::shadesOpacity() const
154 {
137 {
155 return m_shades.opacity();
138 return m_shades.opacity();
156 }
139 }
157
140
158 void AxisItem::setLabelsAngle(int angle)
141 void AxisItem::setLabelsAngle(int angle)
159 {
142 {
160 foreach(QGraphicsItem* item , m_labels.childItems()) {
143 foreach(QGraphicsItem* item , m_labels.childItems()) {
161 QPointF center = item->boundingRect().center();
144 QPointF center = item->boundingRect().center();
162 item->setRotation(angle);
145 item->setRotation(angle);
163 }
146 }
164
147
165 m_labelsAngle=angle;
148 m_labelsAngle=angle;
166 }
149 }
167
150
168 void AxisItem::setLabelsPen(const QPen& pen)
151 void AxisItem::setLabelsPen(const QPen& pen)
169 {
152 {
170 foreach(QGraphicsItem* item , m_labels.childItems()) {
153 foreach(QGraphicsItem* item , m_labels.childItems()) {
171 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
154 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
172 }
155 }
173 }
156 }
174
157
175 void AxisItem::setLabelsBrush(const QBrush& brush)
158 void AxisItem::setLabelsBrush(const QBrush& brush)
176 {
159 {
177 foreach(QGraphicsItem* item , m_labels.childItems()) {
160 foreach(QGraphicsItem* item , m_labels.childItems()) {
178 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
161 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
179 }
162 }
180 }
163 }
181
164
182 void AxisItem::setLabelsFont(const QFont& font)
165 void AxisItem::setLabelsFont(const QFont& font)
183 {
166 {
184 foreach(QGraphicsItem* item , m_labels.childItems()) {
167 foreach(QGraphicsItem* item , m_labels.childItems()) {
185 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
168 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
186 }
169 }
187 }
170 }
188
171
189 void AxisItem::setShadesBrush(const QBrush& brush)
172 void AxisItem::setShadesBrush(const QBrush& brush)
190 {
173 {
191 foreach(QGraphicsItem* item , m_shades.childItems()) {
174 foreach(QGraphicsItem* item , m_shades.childItems()) {
192 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
175 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
193 }
176 }
194 }
177 }
195
178
196 void AxisItem::setShadesPen(const QPen& pen)
179 void AxisItem::setShadesPen(const QPen& pen)
197 {
180 {
198 foreach(QGraphicsItem* item , m_shades.childItems()) {
181 foreach(QGraphicsItem* item , m_shades.childItems()) {
199 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
182 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
200 }
183 }
201 }
184 }
202
185
203 void AxisItem::setAxisPen(const QPen& pen)
186 void AxisItem::setAxisPen(const QPen& pen)
204 {
187 {
205 foreach(QGraphicsItem* item , m_axis.childItems()) {
188 foreach(QGraphicsItem* item , m_axis.childItems()) {
206 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
189 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
207 }
190 }
208 }
191 }
209
192
210 void AxisItem::setGridPen(const QPen& pen)
193 void AxisItem::setGridPen(const QPen& pen)
211 {
194 {
212 foreach(QGraphicsItem* item , m_grid.childItems()) {
195 foreach(QGraphicsItem* item , m_grid.childItems()) {
213 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
196 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
214 }
197 }
215 }
198 }
216
199
217 QVector<qreal> AxisItem::calculateLayout() const
200 QVector<qreal> AxisItem::calculateLayout() const
218 {
201 {
202 Q_ASSERT(m_ticksCount>=2);
203
219 QVector<qreal> points;
204 QVector<qreal> points;
220 points.resize(m_thicksList.size());
205 points.resize(m_ticksCount);
221
206
222 switch (m_type)
207 switch (m_type)
223 {
208 {
224 case X_AXIS:
209 case X_AXIS:
225 {
210 {
226 const qreal deltaX = m_rect.width()/(m_thicksList.size()-1);
211 const qreal deltaX = m_rect.width()/(m_ticksCount-1);
227 for (int i = 0; i < m_thicksList.size(); ++i) {
212 for (int i = 0; i < m_ticksCount; ++i) {
228 int x = i * deltaX + m_rect.left();
213 int x = i * deltaX + m_rect.left();
229 points[i] = x;
214 points[i] = x;
230 }
215 }
231 }
216 }
232 break;
217 break;
233 case Y_AXIS:
218 case Y_AXIS:
234 {
219 {
235 const qreal deltaY = m_rect.height()/(m_thicksList.size()-1);
220 const qreal deltaY = m_rect.height()/(m_ticksCount-1);
236 for (int i = 0; i < m_thicksList.size(); ++i) {
221 for (int i = 0; i < m_ticksCount; ++i) {
237 int y = i * -deltaY + m_rect.bottom();
222 int y = i * -deltaY + m_rect.bottom();
238 points[i] = y;
223 points[i] = y;
239 }
224 }
240 }
225 }
241 break;
226 break;
242 }
227 }
243 return points;
228 return points;
244 }
229 }
245
230
246 void AxisItem::setLayout(const QVector<qreal>& layout)
231 void AxisItem::setLayout(QVector<qreal>& layout)
247 {
232 {
233 int diff = m_layoutVector.size() - layout.size();
234
235 if(diff>0) {
236 deleteItems(diff);
237 }
238 else if(diff<0) {
239 createItems(-diff);
240 }
241
242 QList<QGraphicsItem *> lines = m_grid.childItems();
243 QList<QGraphicsItem *> labels = m_labels.childItems();
244 QList<QGraphicsItem *> shades = m_shades.childItems();
245 QList<QGraphicsItem *> axis = m_axis.childItems();
246
247 Q_ASSERT(labels.size() == m_ticksList.size());
248 Q_ASSERT(layout.size() == m_ticksList.size());
249
250 switch (m_type)
251 {
252 case X_AXIS:
253 {
254 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
255 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
256
257 for (int i = 0; i < layout.size(); ++i) {
258 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
259 lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
260 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
261 labelItem->setText(m_ticksList.at(i));
262 QPointF center = labelItem->boundingRect().center();
263 labelItem->setTransformOriginPoint(center.x(), center.y());
264 labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
265 if(i%2 && i+1 < layout.size()) {
266 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
267 rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height());
268 }
269 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
270 lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
271 }
272 }
273 break;
274
275 case Y_AXIS:
276 {
277 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
278 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
279
280 for (int i = 0; i < layout.size(); ++i) {
281 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
282 lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
283 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
284 labelItem->setText(m_ticksList.at(i));
285 QPointF center = labelItem->boundingRect().center();
286 labelItem->setTransformOriginPoint(center.x(), center.y());
287 labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
288 if(i%2 && i+1 < layout.size()) {
289 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
290 rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]);
291 }
292 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
293 lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
294 }
295 }
296 break;
297 default:
298 qDebug()<<"Unknown axis type";
299 break;
300 }
301
302 if(diff!=0) handleAxisUpdated();
303 m_layoutVector=layout;
304 }
248
305
249 QList<QGraphicsItem *> lines = m_grid.childItems();
306 bool AxisItem::isEmpty()
250 QList<QGraphicsItem *> labels = m_labels.childItems();
307 {
251 QList<QGraphicsItem *> shades = m_shades.childItems();
308 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
252 QList<QGraphicsItem *> axis = m_axis.childItems();
253
254 Q_ASSERT(labels.size() == m_thicksList.size());
255 Q_ASSERT(layout.size() == m_thicksList.size());
256
257 switch (m_type)
258 {
259 case X_AXIS:
260 {
261 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
262 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
263
264 for (int i = 0; i < layout.size(); ++i) {
265 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
266 lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
267 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
268 labelItem->setText(m_thicksList.at(i));
269 QPointF center = labelItem->boundingRect().center();
270 labelItem->setTransformOriginPoint(center.x(), center.y());
271 labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
272 if(i%2 && i+1 < layout.size()){
273 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
274 rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height());
275 }
276 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
277 lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
278 }
279 }
280 break;
281
282 case Y_AXIS:
283 {
284 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
285 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
286
287 for (int i = 0; i < layout.size(); ++i) {
288 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
289 lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
290 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
291 labelItem->setText(m_thicksList.at(i));
292 QPointF center = labelItem->boundingRect().center();
293 labelItem->setTransformOriginPoint(center.x(), center.y());
294 labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
295 if(i%2 && i+1 < layout.size()){
296 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
297 rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]);
298 }
299 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
300 lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
301 }
302 }
303 break;
304 default:
305 qDebug()<<"Unknown axis type";
306 break;
307 }
308
309 m_layoutVector=layout;
310 }
309 }
311
310
312 //handlers
311 //handlers
313
312
314 void AxisItem::handleAxisCategoriesUpdated()
313 void AxisItem::handleAxisCategoriesUpdated()
315 {
314 {
316 updateItem();
315 if(isEmpty()) return;
316 m_ticksList = createLabels(m_ticksCount,m_min,m_max);
317 updateLayout(m_layoutVector);
317 }
318 }
318
319
319 void AxisItem::handleAxisUpdated()
320 void AxisItem::handleAxisUpdated()
320 {
321 {
321
322
322 int count = m_chartAxis->ticksCount();
323 int count = m_chartAxis->ticksCount();
323
324
324 if(m_ticks!=count){
325 if(m_ticksCount!=count){
325 m_ticks=count;
326 handleTicksCountChanged(count);
326 updateItem();
327 }
327 }
328
328
329 if(isEmpty()) return;
329 if(isEmpty()) return;
330
330
331 if(m_chartAxis->isAxisVisible()) {
331 if(m_chartAxis->isAxisVisible()) {
332 setAxisOpacity(100);
332 setAxisOpacity(100);
333 }
333 }
334 else {
334 else {
335 setAxisOpacity(0);
335 setAxisOpacity(0);
336 }
336 }
337
337
338 if(m_chartAxis->isGridVisible()) {
338 if(m_chartAxis->isGridVisible()) {
339 setGridOpacity(100);
339 setGridOpacity(100);
340 }
340 }
341 else {
341 else {
342 setGridOpacity(0);
342 setGridOpacity(0);
343 }
343 }
344
344
345 if(m_chartAxis->labelsVisible())
345 if(m_chartAxis->labelsVisible())
346 {
346 {
347 setLabelsOpacity(100);
347 setLabelsOpacity(100);
348 }
348 }
349 else {
349 else {
350 setLabelsOpacity(0);
350 setLabelsOpacity(0);
351 }
351 }
352
352
353 if(m_chartAxis->shadesVisible()) {
353 if(m_chartAxis->shadesVisible()) {
354 setShadesOpacity(m_chartAxis->shadesOpacity());
354 setShadesOpacity(m_chartAxis->shadesOpacity());
355 }
355 }
356 else {
356 else {
357 setShadesOpacity(0);
357 setShadesOpacity(0);
358 }
358 }
359
359
360 setLabelsAngle(m_chartAxis->labelsAngle());
360 setLabelsAngle(m_chartAxis->labelsAngle());
361 setAxisPen(m_chartAxis->axisPen());
361 setAxisPen(m_chartAxis->axisPen());
362 setLabelsPen(m_chartAxis->labelsPen());
362 setLabelsPen(m_chartAxis->labelsPen());
363 setLabelsBrush(m_chartAxis->labelsBrush());
363 setLabelsBrush(m_chartAxis->labelsBrush());
364 setLabelsFont(m_chartAxis->labelsFont());
364 setLabelsFont(m_chartAxis->labelsFont());
365 setGridPen(m_chartAxis->gridPen());
365 setGridPen(m_chartAxis->gridPen());
366 setShadesPen(m_chartAxis->shadesPen());
366 setShadesPen(m_chartAxis->shadesPen());
367 setShadesBrush(m_chartAxis->shadesBrush());
367 setShadesBrush(m_chartAxis->shadesBrush());
368
368
369 }
369 }
370
370
371 void AxisItem::handleTicksCountChanged(int count)
372 {
373 m_ticksCount=count;
374
375 if(isEmpty()) return;
376 m_ticksList = createLabels(m_ticksCount,m_min,m_max);
377 QVector<qreal> layout = calculateLayout();
378 updateLayout(layout);
379 }
380
371 void AxisItem::handleRangeChanged(qreal min, qreal max)
381 void AxisItem::handleRangeChanged(qreal min, qreal max)
372 {
382 {
373
383
374 m_min = min;
384 m_min = min;
375 m_max = max;
385 m_max = max;
376
386
377 if(isEmpty()) return;
387 if(isEmpty()) return;
378 updateItem();
388 m_ticksList = createLabels(m_ticksCount,m_min,m_max);
389 QVector<qreal> layout = calculateLayout();
390 updateLayout(layout);
379
391
380 }
392 }
381
393
382 void AxisItem::handleGeometryChanged(const QRectF& rect)
394 void AxisItem::handleGeometryChanged(const QRectF& rect)
383 {
395 {
396
384 m_rect = rect;
397 m_rect = rect;
385 if(isEmpty()) return;
398 if(isEmpty()) return;
386 updateItem();
399 m_ticksList = createLabels(m_ticksCount,m_min,m_max);
400 QVector<qreal> layout = calculateLayout();
401 updateLayout(layout);
387 }
402 }
388
403
389 bool AxisItem::isEmpty()
404 //painter
405
406 void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
390 {
407 {
391 return m_rect.isEmpty() || m_min==m_max || m_ticks==0;
408 Q_UNUSED(painter);
409 Q_UNUSED(option);
410 Q_UNUSED(widget);
392 }
411 }
393
412
394 //TODO "nice numbers algorithm"
413 //TODO "nice numbers algorithm"
395 #include "moc_axisitem_p.cpp"
414 #include "moc_axisitem_p.cpp"
396
415
397 QTCOMMERCIALCHART_END_NAMESPACE
416 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,89 +1,90
1 #ifndef AXISITEM_H_
1 #ifndef AXISITEM_H_
2 #define AXISITEM_H_
2 #define AXISITEM_H_
3
3
4 #include "domain_p.h"
4 #include "domain_p.h"
5 #include "chartitem_p.h"
5 #include "chartitem_p.h"
6 #include <QGraphicsItem>
6 #include <QGraphicsItem>
7
7
8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9
9
10 class QChartAxis;
10 class QChartAxis;
11
11
12 class AxisItem : public QObject, public ChartItem
12 class AxisItem : public QObject, public ChartItem
13 {
13 {
14 Q_OBJECT
14 Q_OBJECT
15 public:
15 public:
16 enum AxisType{X_AXIS,Y_AXIS};
16 enum AxisType{X_AXIS,Y_AXIS};
17
17
18 AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
18 AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
19 ~AxisItem();
19 ~AxisItem();
20
20
21 //from QGraphicsItem
21 //from QGraphicsItem
22 QRectF boundingRect() const;
22 QRectF boundingRect() const;
23 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
23 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
24
24
25 AxisType axisType() const {return m_type;};
25 AxisType axisType() const {return m_type;};
26
26
27 void setAxisOpacity(qreal opacity);
27 void setAxisOpacity(qreal opacity);
28 qreal axisOpacity() const;
28 qreal axisOpacity() const;
29
29
30 void setGridOpacity(qreal opacity);
30 void setGridOpacity(qreal opacity);
31 qreal gridOpacity() const;
31 qreal gridOpacity() const;
32
32
33 void setLabelsOpacity(qreal opacity);
33 void setLabelsOpacity(qreal opacity);
34 qreal labelsOpacity() const;
34 qreal labelsOpacity() const;
35
35
36 void setShadesOpacity(qreal opacity);
36 void setShadesOpacity(qreal opacity);
37 qreal shadesOpacity() const;
37 qreal shadesOpacity() const;
38
38
39 void setLabelsAngle(int angle);
39 void setLabelsAngle(int angle);
40 int labelsAngle()const { return m_labelsAngle; }
40 int labelsAngle()const { return m_labelsAngle; }
41
41
42 void setShadesBrush(const QBrush& brush);
42 void setShadesBrush(const QBrush& brush);
43 void setShadesPen(const QPen& pen);
43 void setShadesPen(const QPen& pen);
44
44
45 void setAxisPen(const QPen& pen);
45 void setAxisPen(const QPen& pen);
46 void setGridPen(const QPen& pen);
46 void setGridPen(const QPen& pen);
47
47
48 void setLabelsPen(const QPen& pen);
48 void setLabelsPen(const QPen& pen);
49 void setLabelsBrush(const QBrush& brush);
49 void setLabelsBrush(const QBrush& brush);
50 void setLabelsFont(const QFont& font);
50 void setLabelsFont(const QFont& font);
51
51
52 public slots:
52 public slots:
53 void handleAxisUpdated();//qchartaxis update calls
53 void handleAxisUpdated();
54 void handleAxisCategoriesUpdated();//qchartaxis update calls
54 void handleAxisCategoriesUpdated();
55 void handleRangeChanged(qreal min , qreal max); //domain update calls
55 void handleRangeChanged(qreal min , qreal max);
56 void handleGeometryChanged(const QRectF& size); //geometry update calls
56 void handleTicksCountChanged(int count);
57 void handleGeometryChanged(const QRectF& size);
57
58
58 public:
59 public:
59 virtual void updateItem();
60 virtual void updateLayout(QVector<qreal>& layout);
60 QVector<qreal> calculateLayout() const;
61 void setLayout(QVector<qreal>& layout);
61 void setLayout(const QVector<qreal>& points);
62 QVector<qreal> layout() { return m_layoutVector;};
62 QVector<qreal> layout() { return m_layoutVector;};
63
63
64 private:
64 private:
65 inline bool isEmpty();
65 inline bool isEmpty();
66 void clear(int count);
67 void createItems(int count);
66 void createItems(int count);
68 QStringList createLabels(int ticks, qreal min, qreal max);
67 void deleteItems(int count);
68 QVector<qreal> calculateLayout() const;
69 QStringList createLabels(int ticks, qreal min, qreal max) const;
69
70
70 private:
71 private:
71 QChartAxis* m_chartAxis;
72 QChartAxis* m_chartAxis;
72 AxisType m_type;
73 AxisType m_type;
73 QRectF m_rect;
74 QRectF m_rect;
74 int m_labelsAngle;
75 int m_labelsAngle;
75 QGraphicsItemGroup m_grid;
76 QGraphicsItemGroup m_grid;
76 QGraphicsItemGroup m_shades;
77 QGraphicsItemGroup m_shades;
77 QGraphicsItemGroup m_labels;
78 QGraphicsItemGroup m_labels;
78 QGraphicsItemGroup m_axis;
79 QGraphicsItemGroup m_axis;
79 QStringList m_thicksList;
80 QStringList m_ticksList;
80 QVector<qreal> m_layoutVector;
81 QVector<qreal> m_layoutVector;
81 qreal m_min;
82 qreal m_min;
82 qreal m_max;
83 qreal m_max;
83 int m_ticks;
84 int m_ticksCount;
84
85
85 };
86 };
86
87
87 QTCOMMERCIALCHART_END_NAMESPACE
88 QTCOMMERCIALCHART_END_NAMESPACE
88
89
89 #endif /* AXISITEM_H_ */
90 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,177 +1,178
1 #include "barpresenterbase_p.h"
1 #include "barpresenterbase_p.h"
2 #include "bar_p.h"
2 #include "bar_p.h"
3 #include "barvalue_p.h"
3 #include "barvalue_p.h"
4 #include "separator_p.h"
4 #include "separator_p.h"
5 #include "qbarset.h"
5 #include "qbarset.h"
6 #include "qbarseries.h"
6 #include "qbarseries.h"
7 #include "qchart.h"
7 #include "qchart.h"
8 #include "qchartaxis.h"
8 #include "qchartaxis.h"
9 #include "qchartaxiscategories.h"
9 #include "qchartaxiscategories.h"
10 #include <QDebug>
10 #include <QDebug>
11 #include <QToolTip>
11 #include <QToolTip>
12
12
13 QTCOMMERCIALCHART_BEGIN_NAMESPACE
13 QTCOMMERCIALCHART_BEGIN_NAMESPACE
14
14
15 BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent)
15 BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent)
16 : ChartItem(parent)
16 : ChartItem(parent)
17 ,mLayoutSet(false)
17 ,mLayoutSet(false)
18 ,mSeparatorsEnabled(false)
18 ,mSeparatorsEnabled(false)
19 ,mSeries(series)
19 ,mSeries(series)
20 ,mChart(parent)
20 ,mChart(parent)
21 {
21 {
22 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
22 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
23 initAxisLabels();
23 initAxisLabels();
24 dataChanged();
24 dataChanged();
25 }
25 }
26
26
27 BarPresenterBase::~BarPresenterBase()
27 BarPresenterBase::~BarPresenterBase()
28 {
28 {
29 disconnect(this,SLOT(showToolTip(QPoint,QString)));
29 disconnect(this,SLOT(showToolTip(QPoint,QString)));
30 }
30 }
31
31
32 void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
32 void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
33 {
33 {
34 if (!mLayoutSet) {
34 if (!mLayoutSet) {
35 qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
35 qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
36 return;
36 return;
37 }
37 }
38 foreach(QGraphicsItem* i, childItems()) {
38 foreach(QGraphicsItem* i, childItems()) {
39 i->paint(painter,option,widget);
39 i->paint(painter,option,widget);
40 }
40 }
41 }
41 }
42
42
43 QRectF BarPresenterBase::boundingRect() const
43 QRectF BarPresenterBase::boundingRect() const
44 {
44 {
45 return QRectF(0,0,mWidth,mHeight);
45 return QRectF(0,0,mWidth,mHeight);
46 }
46 }
47
47
48 void BarPresenterBase::dataChanged()
48 void BarPresenterBase::dataChanged()
49 {
49 {
50 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
50 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
51 // Delete old bars
51 // Delete old bars
52 foreach (QGraphicsItem* item, childItems()) {
52 foreach (QGraphicsItem* item, childItems()) {
53 delete item;
53 delete item;
54 }
54 }
55
55
56 mBars.clear();
56 mBars.clear();
57 mSeparators.clear();
57 mSeparators.clear();
58 mFloatingValues.clear();
58 mFloatingValues.clear();
59
59
60 // Create new graphic items for bars
60 // Create new graphic items for bars
61 for (int c=0; c<mSeries->categoryCount(); c++) {
61 for (int c=0; c<mSeries->categoryCount(); c++) {
62 QString category = mSeries->categoryName(c);
62 QString category = mSeries->categoryName(c);
63 for (int s=0; s<mSeries->barsetCount(); s++) {
63 for (int s=0; s<mSeries->barsetCount(); s++) {
64 QBarSet *set = mSeries->barsetAt(s);
64 QBarSet *set = mSeries->barsetAt(s);
65 Bar *bar = new Bar(category,this);
65 Bar *bar = new Bar(category,this);
66 childItems().append(bar);
66 childItems().append(bar);
67 mBars.append(bar);
67 mBars.append(bar);
68 connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
68 connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
69 connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
69 connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
70 connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
70 connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
71 connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
71 connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
72 }
72 }
73 }
73 }
74
74
75 // Create separators
75 // Create separators
76 int count = mSeries->categoryCount() - 1; // There is one less separator than columns
76 int count = mSeries->categoryCount() - 1; // There is one less separator than columns
77 for (int i=0; i<count; i++) {
77 for (int i=0; i<count; i++) {
78 Separator* sep = new Separator(this);
78 Separator* sep = new Separator(this);
79 sep->setColor(QColor(255,0,0,255)); // TODO: color for separations from theme
79 sep->setColor(QColor(255,0,0,255)); // TODO: color for separations from theme
80 sep->setVisible(mSeparatorsEnabled);
80 sep->setVisible(mSeparatorsEnabled);
81 childItems().append(sep);
81 childItems().append(sep);
82 mSeparators.append(sep);
82 mSeparators.append(sep);
83 }
83 }
84
84
85 // Create floating values
85 // Create floating values
86 for (int category=0; category<mSeries->categoryCount(); category++) {
86 for (int category=0; category<mSeries->categoryCount(); category++) {
87 for (int s=0; s<mSeries->barsetCount(); s++) {
87 for (int s=0; s<mSeries->barsetCount(); s++) {
88 QBarSet *set = mSeries->barsetAt(s);
88 QBarSet *set = mSeries->barsetAt(s);
89 BarValue *value = new BarValue(*set, this);
89 BarValue *value = new BarValue(*set, this);
90 childItems().append(value);
90 childItems().append(value);
91 mFloatingValues.append(value);
91 mFloatingValues.append(value);
92 connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
92 connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
93 }
93 }
94 }
94 }
95 }
95 }
96
96
97 void BarPresenterBase::initAxisLabels()
97 void BarPresenterBase::initAxisLabels()
98 {
98 {
99 int count = mSeries->categoryCount();
99 int count = mSeries->categoryCount();
100 if (0 == count) {
100 if (0 == count) {
101 return;
101 return;
102 }
102 }
103 count++;
104
103
105 mChart->axisX()->setTicksCount(count);
104 mChart->axisX()->setTicksCount(count+2);
106
105
107 qreal min = 0;
106 qreal min = 0;
108 qreal max = count;
107 qreal max = count+1;
109
108
110 mChart->axisX()->setMin(min);
109 mChart->axisX()->setMin(min);
111 mChart->axisX()->setMax(max);
110 mChart->axisX()->setMax(max);
112 min++;
111
113 QChartAxisCategories* categories = mChart->axisX()->categories();
112 QChartAxisCategories* categories = mChart->axisX()->categories();
114 categories->clear();
113 categories->clear();
115 for (int i=0; i<count-1; i++) {
114 for (int i=0; i<count; i++) {
116 categories->insert(min,mSeries->categoryName(i));
115 categories->insert(i+1,mSeries->categoryName(i));
117 min++;
118 }
116 }
117
118
119
119 mChart->axisX()->setLabelsVisible(true);
120 mChart->axisX()->setLabelsVisible(true);
120 }
121 }
121
122
122 //handlers
123 //handlers
123
124
124 void BarPresenterBase::handleModelChanged(int index)
125 void BarPresenterBase::handleModelChanged(int index)
125 {
126 {
126 // qDebug() << "BarPresenterBase::handleModelChanged" << index;
127 // qDebug() << "BarPresenterBase::handleModelChanged" << index;
127 dataChanged();
128 dataChanged();
128 }
129 }
129
130
130 void BarPresenterBase::handleDomainChanged(const Domain& domain)
131 void BarPresenterBase::handleDomainChanged(const Domain& domain)
131 {
132 {
132 qDebug() << "BarPresenterBase::handleDomainChanged";
133 qDebug() << "BarPresenterBase::handleDomainChanged";
133 /*
134 /*
134 int count = mSeries->categoryCount();
135 int count = mSeries->categoryCount();
135 if (0 == count) {
136 if (0 == count) {
136 return;
137 return;
137 }
138 }
138
139
139 // Position labels to domain
140 // Position labels to domain
140 qreal min = domain.minX();
141 qreal min = domain.minX();
141 qreal max = domain.maxX();
142 qreal max = domain.maxX();
142 qreal step = (max-min)/count;
143 qreal step = (max-min)/count;
143 QChartAxisCategories& categories = mChart->axisX()->categories();
144 QChartAxisCategories& categories = mChart->axisX()->categories();
144 categories.clear();
145 categories.clear();
145 for (int i=0; i<count; i++) {
146 for (int i=0; i<count; i++) {
146 categories.insert(min,mSeries->categoryName(i));
147 categories.insert(min,mSeries->categoryName(i));
147 min += step;
148 min += step;
148 }
149 }
149 */
150 */
150 }
151 }
151
152
152 void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
153 void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
153 {
154 {
154 mWidth = rect.width();
155 mWidth = rect.width();
155 mHeight = rect.height();
156 mHeight = rect.height();
156 layoutChanged();
157 layoutChanged();
157 mLayoutSet = true;
158 mLayoutSet = true;
158 setPos(rect.topLeft());
159 setPos(rect.topLeft());
159 }
160 }
160
161
161 void BarPresenterBase::showToolTip(QPoint pos, QString tip)
162 void BarPresenterBase::showToolTip(QPoint pos, QString tip)
162 {
163 {
163 // TODO: cool tooltip instead of default
164 // TODO: cool tooltip instead of default
164 QToolTip::showText(pos,tip);
165 QToolTip::showText(pos,tip);
165 }
166 }
166
167
167 void BarPresenterBase::enableSeparators(bool enabled)
168 void BarPresenterBase::enableSeparators(bool enabled)
168 {
169 {
169 for (int i=0; i<mSeparators.count(); i++) {
170 for (int i=0; i<mSeparators.count(); i++) {
170 mSeparators.at(i)->setVisible(enabled);
171 mSeparators.at(i)->setVisible(enabled);
171 }
172 }
172 mSeparatorsEnabled = enabled;
173 mSeparatorsEnabled = enabled;
173 }
174 }
174
175
175 #include "moc_barpresenterbase_p.cpp"
176 #include "moc_barpresenterbase_p.cpp"
176
177
177 QTCOMMERCIALCHART_END_NAMESPACE
178 QTCOMMERCIALCHART_END_NAMESPACE
General Comments 0
You need to be logged in to leave comments. Login now