@@ -49,7 +49,7 void AxisAnimation::setAnimationType(Animation type) | |||||
49 | m_type = type; |
|
49 | m_type = type; | |
50 | } |
|
50 | } | |
51 |
|
51 | |||
52 |
void AxisAnimation::setAnimationPoint(const QPointF& |
|
52 | void AxisAnimation::setAnimationPoint(const QPointF &point) | |
53 | { |
|
53 | { | |
54 | if (state() != QAbstractAnimation::Stopped) |
|
54 | if (state() != QAbstractAnimation::Stopped) | |
55 | stop(); |
|
55 | stop(); |
@@ -44,7 +44,7 public: | |||||
44 | AxisAnimation(ChartAxis *axis); |
|
44 | AxisAnimation(ChartAxis *axis); | |
45 | ~AxisAnimation(); |
|
45 | ~AxisAnimation(); | |
46 | void setAnimationType(Animation type); |
|
46 | void setAnimationType(Animation type); | |
47 |
void setAnimationPoint(const QPointF& |
|
47 | void setAnimationPoint(const QPointF &point); | |
48 | void setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout); |
|
48 | void setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout); | |
49 | protected: |
|
49 | protected: | |
50 | QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const; |
|
50 | QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const; |
@@ -35,7 +35,7 PieAnimation::~PieAnimation() | |||||
35 | { |
|
35 | { | |
36 | } |
|
36 | } | |
37 |
|
37 | |||
38 |
ChartAnimation* |
|
38 | ChartAnimation *PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData) | |
39 | { |
|
39 | { | |
40 | PieSliceAnimation *animation = m_animations.value(sliceItem); |
|
40 | PieSliceAnimation *animation = m_animations.value(sliceItem); | |
41 | Q_ASSERT(animation); |
|
41 | Q_ASSERT(animation); | |
@@ -48,7 +48,7 ChartAnimation* PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSlic | |||||
48 | return animation; |
|
48 | return animation; | |
49 | } |
|
49 | } | |
50 |
|
50 | |||
51 |
ChartAnimation* |
|
51 | ChartAnimation *PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation) | |
52 | { |
|
52 | { | |
53 | PieSliceAnimation *animation = new PieSliceAnimation(sliceItem); |
|
53 | PieSliceAnimation *animation = new PieSliceAnimation(sliceItem); | |
54 | m_animations.insert(sliceItem, animation); |
|
54 | m_animations.insert(sliceItem, animation); | |
@@ -71,7 +71,7 ChartAnimation* PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceDa | |||||
71 | return animation; |
|
71 | return animation; | |
72 | } |
|
72 | } | |
73 |
|
73 | |||
74 |
ChartAnimation* |
|
74 | ChartAnimation *PieAnimation::removeSlice(PieSliceItem *sliceItem) | |
75 | { |
|
75 | { | |
76 | PieSliceAnimation *animation = m_animations.value(sliceItem); |
|
76 | PieSliceAnimation *animation = m_animations.value(sliceItem); | |
77 | Q_ASSERT(animation); |
|
77 | Q_ASSERT(animation); |
@@ -45,9 +45,9 class PieAnimation : public ChartAnimation | |||||
45 | public: |
|
45 | public: | |
46 | PieAnimation(PieChartItem *item); |
|
46 | PieAnimation(PieChartItem *item); | |
47 | ~PieAnimation(); |
|
47 | ~PieAnimation(); | |
48 |
ChartAnimation* |
|
48 | ChartAnimation *updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue); | |
49 |
ChartAnimation* |
|
49 | ChartAnimation *addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation); | |
50 |
ChartAnimation* |
|
50 | ChartAnimation *removeSlice(PieSliceItem *sliceItem); | |
51 |
|
51 | |||
52 | public: // from QVariantAnimation |
|
52 | public: // from QVariantAnimation | |
53 | void updateCurrentValue(const QVariant &value); |
|
53 | void updateCurrentValue(const QVariant &value); |
@@ -27,9 +27,10 Q_DECLARE_METATYPE(SplineVector) | |||||
27 |
|
27 | |||
28 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
28 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
29 |
|
29 | |||
30 |
SplineAnimation::SplineAnimation(SplineChartItem* |
|
30 | SplineAnimation::SplineAnimation(SplineChartItem *item) | |
31 |
|
|
31 | : XYAnimation(item), | |
32 | m_valid(false) |
|
32 | m_item(item), | |
|
33 | m_valid(false) | |||
33 | { |
|
34 | { | |
34 | } |
|
35 | } | |
35 |
|
36 |
@@ -51,8 +51,8 public: | |||||
51 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); |
|
51 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); | |
52 | QPainterPath shape() const; |
|
52 | QPainterPath shape() const; | |
53 |
|
53 | |||
54 |
LineChartItem* |
|
54 | LineChartItem *upperLineItem() const { return m_upper; } | |
55 |
LineChartItem* |
|
55 | LineChartItem *lowerLineItem() const { return m_lower; } | |
56 |
|
56 | |||
57 | void updatePath(); |
|
57 | void updatePath(); | |
58 |
|
58 | |||
@@ -68,9 +68,9 public Q_SLOTS: | |||||
68 | void handleGeometryChanged(const QRectF &size); |
|
68 | void handleGeometryChanged(const QRectF &size); | |
69 |
|
69 | |||
70 | private: |
|
70 | private: | |
71 |
QAreaSeries* |
|
71 | QAreaSeries *m_series; | |
72 |
LineChartItem* |
|
72 | LineChartItem *m_upper; | |
73 |
LineChartItem* |
|
73 | LineChartItem *m_lower; | |
74 | QPainterPath m_path; |
|
74 | QPainterPath m_path; | |
75 | QRectF m_rect; |
|
75 | QRectF m_rect; | |
76 | QRectF m_clipRect; |
|
76 | QRectF m_clipRect; | |
@@ -84,20 +84,21 private: | |||||
84 | class AreaBoundItem : public LineChartItem |
|
84 | class AreaBoundItem : public LineChartItem | |
85 | { |
|
85 | { | |
86 | public: |
|
86 | public: | |
87 |
AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter* |
|
87 | AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter *presenter) | |
88 | : LineChartItem(lineSeries, 0), m_item(item) |
|
88 | : LineChartItem(lineSeries, 0), m_item(item) | |
89 | { |
|
89 | { | |
90 | setPresenter(presenter); |
|
90 | setPresenter(presenter); | |
91 | } |
|
91 | } | |
92 | ~AreaBoundItem() {} |
|
92 | ~AreaBoundItem() {} | |
93 |
|
93 | |||
94 |
void updateGeometry() |
|
94 | void updateGeometry() | |
|
95 | { | |||
95 | LineChartItem::updateGeometry(); |
|
96 | LineChartItem::updateGeometry(); | |
96 | m_item->updatePath(); |
|
97 | m_item->updatePath(); | |
97 | } |
|
98 | } | |
98 |
|
99 | |||
99 | private: |
|
100 | private: | |
100 |
AreaChartItem* |
|
101 | AreaChartItem *m_item; | |
101 | }; |
|
102 | }; | |
102 |
|
103 | |||
103 | QTCOMMERCIALCHART_END_NAMESPACE |
|
104 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -195,13 +195,13 QAbstractSeries::SeriesType QAreaSeries::type() const | |||||
195 | /*! |
|
195 | /*! | |
196 | Sets the \a series that is to be used as the area chart upper series. |
|
196 | Sets the \a series that is to be used as the area chart upper series. | |
197 | */ |
|
197 | */ | |
198 |
void QAreaSeries::setUpperSeries(QLineSeries* |
|
198 | void QAreaSeries::setUpperSeries(QLineSeries *series) | |
199 | { |
|
199 | { | |
200 | Q_D(QAreaSeries); |
|
200 | Q_D(QAreaSeries); | |
201 | d->m_upperSeries = series; |
|
201 | d->m_upperSeries = series; | |
202 | } |
|
202 | } | |
203 |
|
203 | |||
204 |
QLineSeries* |
|
204 | QLineSeries *QAreaSeries::upperSeries() const | |
205 | { |
|
205 | { | |
206 | Q_D(const QAreaSeries); |
|
206 | Q_D(const QAreaSeries); | |
207 | return d->m_upperSeries; |
|
207 | return d->m_upperSeries; | |
@@ -210,13 +210,13 QLineSeries* QAreaSeries::upperSeries() const | |||||
210 | /*! |
|
210 | /*! | |
211 | Sets the \a series that is to be used as the area chart lower series. |
|
211 | Sets the \a series that is to be used as the area chart lower series. | |
212 | */ |
|
212 | */ | |
213 |
void QAreaSeries::setLowerSeries(QLineSeries* |
|
213 | void QAreaSeries::setLowerSeries(QLineSeries *series) | |
214 | { |
|
214 | { | |
215 | Q_D(QAreaSeries); |
|
215 | Q_D(QAreaSeries); | |
216 | d->m_lowerSeries = series; |
|
216 | d->m_lowerSeries = series; | |
217 | } |
|
217 | } | |
218 |
|
218 | |||
219 |
QLineSeries* |
|
219 | QLineSeries *QAreaSeries::lowerSeries() const | |
220 | { |
|
220 | { | |
221 | Q_D(const QAreaSeries); |
|
221 | Q_D(const QAreaSeries); | |
222 | return d->m_lowerSeries; |
|
222 | return d->m_lowerSeries; | |
@@ -314,7 +314,7 bool QAreaSeries::pointsVisible() const | |||||
314 |
|
314 | |||
315 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
315 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
316 |
|
316 | |||
317 |
QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries* |
|
317 | QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q) | |
318 | : QAbstractSeriesPrivate(q), |
|
318 | : QAbstractSeriesPrivate(q), | |
319 | m_upperSeries(upperSeries), |
|
319 | m_upperSeries(upperSeries), | |
320 | m_lowerSeries(lowerSeries), |
|
320 | m_lowerSeries(lowerSeries), | |
@@ -322,7 +322,7 QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lo | |||||
322 | { |
|
322 | { | |
323 | } |
|
323 | } | |
324 |
|
324 | |||
325 |
void QAreaSeriesPrivate::scaleDomain(Domain& |
|
325 | void QAreaSeriesPrivate::scaleDomain(Domain &domain) | |
326 | { |
|
326 | { | |
327 | Q_Q(QAreaSeries); |
|
327 | Q_Q(QAreaSeries); | |
328 |
|
328 | |||
@@ -331,8 +331,8 void QAreaSeriesPrivate::scaleDomain(Domain& domain) | |||||
331 | qreal maxX(domain.maxX()); |
|
331 | qreal maxX(domain.maxX()); | |
332 | qreal maxY(domain.maxY()); |
|
332 | qreal maxY(domain.maxY()); | |
333 |
|
333 | |||
334 |
QLineSeries* |
|
334 | QLineSeries *upperSeries = q->upperSeries(); | |
335 |
QLineSeries* |
|
335 | QLineSeries *lowerSeries = q->lowerSeries(); | |
336 |
|
336 | |||
337 | const QList<QPointF>& points = upperSeries->points(); |
|
337 | const QList<QPointF>& points = upperSeries->points(); | |
338 |
|
338 | |||
@@ -361,11 +361,11 void QAreaSeriesPrivate::scaleDomain(Domain& domain) | |||||
361 | domain.setRange(minX, maxX, minY, maxY); |
|
361 | domain.setRange(minX, maxX, minY, maxY); | |
362 | } |
|
362 | } | |
363 |
|
363 | |||
364 |
ChartElement* |
|
364 | ChartElement *QAreaSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
365 | { |
|
365 | { | |
366 | Q_Q(QAreaSeries); |
|
366 | Q_Q(QAreaSeries); | |
367 |
|
367 | |||
368 |
AreaChartItem* |
|
368 | AreaChartItem *area = new AreaChartItem(q, presenter); | |
369 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) { |
|
369 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) { | |
370 | area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem())); |
|
370 | area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem())); | |
371 | if (q->lowerSeries()) |
|
371 | if (q->lowerSeries()) | |
@@ -375,15 +375,15 ChartElement* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter) | |||||
375 | return area; |
|
375 | return area; | |
376 | } |
|
376 | } | |
377 |
|
377 | |||
378 |
QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* |
|
378 | QList<LegendMarker *> QAreaSeriesPrivate::createLegendMarker(QLegend *legend) | |
379 | { |
|
379 | { | |
380 | Q_Q(QAreaSeries); |
|
380 | Q_Q(QAreaSeries); | |
381 | QList<LegendMarker*> list; |
|
381 | QList<LegendMarker *> list; | |
382 | return list << new AreaLegendMarker(q, legend); |
|
382 | return list << new AreaLegendMarker(q, legend); | |
383 | } |
|
383 | } | |
384 |
|
384 | |||
385 |
|
385 | |||
386 |
void QAreaSeriesPrivate::initializeAxis(QAbstractAxis* |
|
386 | void QAreaSeriesPrivate::initializeAxis(QAbstractAxis *axis) | |
387 | { |
|
387 | { | |
388 | Q_UNUSED(axis); |
|
388 | Q_UNUSED(axis); | |
389 | } |
|
389 | } |
@@ -46,10 +46,10 public: | |||||
46 | public: |
|
46 | public: | |
47 | QAbstractSeries::SeriesType type() const; |
|
47 | QAbstractSeries::SeriesType type() const; | |
48 |
|
48 | |||
49 |
void setUpperSeries(QLineSeries* |
|
49 | void setUpperSeries(QLineSeries *series); | |
50 |
QLineSeries* |
|
50 | QLineSeries *upperSeries() const; | |
51 |
void setLowerSeries(QLineSeries* |
|
51 | void setLowerSeries(QLineSeries *series); | |
52 |
QLineSeries* |
|
52 | QLineSeries *lowerSeries() const; | |
53 |
|
53 | |||
54 | void setPen(const QPen &pen); |
|
54 | void setPen(const QPen &pen); | |
55 | QPen pen() const; |
|
55 | QPen pen() const; |
@@ -41,12 +41,12 class QAreaSeriesPrivate: public QAbstractSeriesPrivate | |||||
41 | Q_OBJECT |
|
41 | Q_OBJECT | |
42 |
|
42 | |||
43 | public: |
|
43 | public: | |
44 |
QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries* |
|
44 | QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q); | |
45 |
|
45 | |||
46 |
void scaleDomain(Domain& |
|
46 | void scaleDomain(Domain &domain); | |
47 |
ChartElement* |
|
47 | ChartElement *createGraphics(ChartPresenter *presenter); | |
48 |
QList<LegendMarker*> createLegendMarker(QLegend* |
|
48 | QList<LegendMarker *> createLegendMarker(QLegend *legend); | |
49 |
void initializeAxis(QAbstractAxis* |
|
49 | void initializeAxis(QAbstractAxis *axis); | |
50 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; |
|
50 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
51 |
|
51 | |||
52 | Q_SIGNALS: |
|
52 | Q_SIGNALS: | |
@@ -55,8 +55,8 Q_SIGNALS: | |||||
55 | protected: |
|
55 | protected: | |
56 | QBrush m_brush; |
|
56 | QBrush m_brush; | |
57 | QPen m_pen; |
|
57 | QPen m_pen; | |
58 |
QLineSeries* |
|
58 | QLineSeries *m_upperSeries; | |
59 |
QLineSeries* |
|
59 | QLineSeries *m_lowerSeries; | |
60 | bool m_pointsVisible; |
|
60 | bool m_pointsVisible; | |
61 | private: |
|
61 | private: | |
62 | Q_DECLARE_PUBLIC(QAreaSeries); |
|
62 | Q_DECLARE_PUBLIC(QAreaSeries); |
@@ -109,16 +109,16 void ChartBarCategoryAxisX::updateGeometry() | |||||
109 |
|
109 | |||
110 | const qreal delta = chartRect.width() / (m_categoriesAxis->d_ptr->count()); |
|
110 | const qreal delta = chartRect.width() / (m_categoriesAxis->d_ptr->count()); | |
111 |
|
111 | |||
112 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
112 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
113 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); |
|
113 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); | |
114 |
|
114 | |||
115 | qreal width = chartRect.left(); |
|
115 | qreal width = chartRect.left(); | |
116 | for (int i = 0; i < layout.size(); ++i) { |
|
116 | for (int i = 0; i < layout.size(); ++i) { | |
117 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
117 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
118 | lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom()); |
|
118 | lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom()); | |
119 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
119 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
120 | labelItem->setText(ticksList.at(i)); |
|
120 | labelItem->setText(ticksList.at(i)); | |
121 |
const QRectF& |
|
121 | const QRectF &rect = labelItem->boundingRect(); | |
122 | QPointF center = rect.center(); |
|
122 | QPointF center = rect.center(); | |
123 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
123 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
124 |
|
124 | |||
@@ -135,10 +135,10 void ChartBarCategoryAxisX::updateGeometry() | |||||
135 | } |
|
135 | } | |
136 |
|
136 | |||
137 | if ((i + 1) % 2 && i > 1) { |
|
137 | if ((i + 1) % 2 && i > 1) { | |
138 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
138 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
139 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); |
|
139 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); | |
140 | } |
|
140 | } | |
141 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
141 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
142 | lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5); |
|
142 | lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5); | |
143 | } |
|
143 | } | |
144 | } |
|
144 | } | |
@@ -152,7 +152,7 void ChartBarCategoryAxisX::handleAxisUpdated() | |||||
152 | ChartAxis::handleAxisUpdated(); |
|
152 | ChartAxis::handleAxisUpdated(); | |
153 | } |
|
153 | } | |
154 |
|
154 | |||
155 |
QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& |
|
155 | QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
156 | { |
|
156 | { | |
157 | Q_UNUSED(constraint) |
|
157 | Q_UNUSED(constraint) | |
158 |
|
158 |
@@ -45,7 +45,7 public: | |||||
45 | ~ChartBarCategoryAxisX(); |
|
45 | ~ChartBarCategoryAxisX(); | |
46 |
|
46 | |||
47 | AxisType axisType() const { return X_AXIS;} |
|
47 | AxisType axisType() const { return X_AXIS;} | |
48 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
48 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
49 | protected: |
|
49 | protected: | |
50 | QVector<qreal> calculateLayout() const; |
|
50 | QVector<qreal> calculateLayout() const; | |
51 | void updateGeometry(); |
|
51 | void updateGeometry(); |
@@ -107,16 +107,16 void ChartBarCategoryAxisY::updateGeometry() | |||||
107 |
|
107 | |||
108 | const qreal delta = chartRect.height() / (m_categoriesAxis->d_ptr->count()); |
|
108 | const qreal delta = chartRect.height() / (m_categoriesAxis->d_ptr->count()); | |
109 |
|
109 | |||
110 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
110 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
111 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); |
|
111 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); | |
112 |
|
112 | |||
113 | qreal height = chartRect.bottom(); |
|
113 | qreal height = chartRect.bottom(); | |
114 | for (int i = 0; i < layout.size(); ++i) { |
|
114 | for (int i = 0; i < layout.size(); ++i) { | |
115 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
115 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
116 | lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]); |
|
116 | lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]); | |
117 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
117 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
118 | labelItem->setText(ticksList.at(i)); |
|
118 | labelItem->setText(ticksList.at(i)); | |
119 |
const QRectF& |
|
119 | const QRectF &rect = labelItem->boundingRect(); | |
120 | QPointF center = rect.center(); |
|
120 | QPointF center = rect.center(); | |
121 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
121 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
122 |
|
122 | |||
@@ -133,10 +133,10 void ChartBarCategoryAxisY::updateGeometry() | |||||
133 | } |
|
133 | } | |
134 |
|
134 | |||
135 | if ((i + 1) % 2 && i > 1) { |
|
135 | if ((i + 1) % 2 && i > 1) { | |
136 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
136 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
137 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); |
|
137 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); | |
138 | } |
|
138 | } | |
139 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
139 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
140 | lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]); |
|
140 | lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]); | |
141 | } |
|
141 | } | |
142 | } |
|
142 | } | |
@@ -152,7 +152,7 void ChartBarCategoryAxisY::handleAxisUpdated() | |||||
152 | ChartAxis::handleAxisUpdated(); |
|
152 | ChartAxis::handleAxisUpdated(); | |
153 | } |
|
153 | } | |
154 |
|
154 | |||
155 |
QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& |
|
155 | QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
156 | { |
|
156 | { | |
157 | Q_UNUSED(constraint) |
|
157 | Q_UNUSED(constraint) | |
158 |
|
158 |
@@ -45,7 +45,7 public: | |||||
45 | ~ChartBarCategoryAxisY(); |
|
45 | ~ChartBarCategoryAxisY(); | |
46 |
|
46 | |||
47 | AxisType axisType() const { return Y_AXIS;} |
|
47 | AxisType axisType() const { return Y_AXIS;} | |
48 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
48 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
49 | protected: |
|
49 | protected: | |
50 | QVector<qreal> calculateLayout() const; |
|
50 | QVector<qreal> calculateLayout() const; | |
51 | void updateGeometry(); |
|
51 | void updateGeometry(); |
@@ -284,7 +284,7 QString QBarCategoryAxis::at(int index) const | |||||
284 | /*! |
|
284 | /*! | |
285 | Sets minimum category to \a min. |
|
285 | Sets minimum category to \a min. | |
286 | */ |
|
286 | */ | |
287 |
void QBarCategoryAxis::setMin(const QString& |
|
287 | void QBarCategoryAxis::setMin(const QString &min) | |
288 | { |
|
288 | { | |
289 | Q_D(QBarCategoryAxis); |
|
289 | Q_D(QBarCategoryAxis); | |
290 | setRange(min, d->m_maxCategory); |
|
290 | setRange(min, d->m_maxCategory); | |
@@ -302,7 +302,7 QString QBarCategoryAxis::min() const | |||||
302 | /*! |
|
302 | /*! | |
303 | Sets maximum category to \a max. |
|
303 | Sets maximum category to \a max. | |
304 | */ |
|
304 | */ | |
305 |
void QBarCategoryAxis::setMax(const QString& |
|
305 | void QBarCategoryAxis::setMax(const QString &max) | |
306 | { |
|
306 | { | |
307 | Q_D(QBarCategoryAxis); |
|
307 | Q_D(QBarCategoryAxis); | |
308 | setRange(d->m_minCategory, max); |
|
308 | setRange(d->m_minCategory, max); | |
@@ -320,7 +320,7 QString QBarCategoryAxis::max() const | |||||
320 | /*! |
|
320 | /*! | |
321 | Sets range from \a minCategory to \a maxCategory |
|
321 | Sets range from \a minCategory to \a maxCategory | |
322 | */ |
|
322 | */ | |
323 |
void QBarCategoryAxis::setRange(const QString& |
|
323 | void QBarCategoryAxis::setRange(const QString &minCategory, const QString &maxCategory) | |
324 | { |
|
324 | { | |
325 | Q_D(QBarCategoryAxis); |
|
325 | Q_D(QBarCategoryAxis); | |
326 |
|
326 | |||
@@ -373,11 +373,11 QAbstractAxis::AxisType QBarCategoryAxis::type() const | |||||
373 |
|
373 | |||
374 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
374 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
375 |
|
375 | |||
376 |
QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis* |
|
376 | QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis *q) | |
377 | QAbstractAxisPrivate(q), |
|
377 | : QAbstractAxisPrivate(q), | |
378 | m_min(0.0), |
|
378 | m_min(0.0), | |
379 | m_max(0.0), |
|
379 | m_max(0.0), | |
380 | m_count(0) |
|
380 | m_count(0) | |
381 | { |
|
381 | { | |
382 |
|
382 | |||
383 | } |
|
383 | } | |
@@ -408,7 +408,7 void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max) | |||||
408 | void QBarCategoryAxisPrivate::handleDomainUpdated() |
|
408 | void QBarCategoryAxisPrivate::handleDomainUpdated() | |
409 | { |
|
409 | { | |
410 | Q_Q(QBarCategoryAxis); |
|
410 | Q_Q(QBarCategoryAxis); | |
411 |
Domain* |
|
411 | Domain *domain = qobject_cast<Domain *>(sender()); | |
412 |
|
412 | |||
413 | if (m_orientation == Qt::Horizontal) { |
|
413 | if (m_orientation == Qt::Horizontal) { | |
414 | m_min = domain->minX(); |
|
414 | m_min = domain->minX(); | |
@@ -442,7 +442,7 void QBarCategoryAxisPrivate::handleDomainUpdated() | |||||
442 | emit q->rangeChanged(m_minCategory, m_maxCategory); |
|
442 | emit q->rangeChanged(m_minCategory, m_maxCategory); | |
443 | } |
|
443 | } | |
444 |
|
444 | |||
445 |
ChartAxis* |
|
445 | ChartAxis *QBarCategoryAxisPrivate::createGraphics(ChartPresenter *presenter) | |
446 | { |
|
446 | { | |
447 | Q_Q(QBarCategoryAxis); |
|
447 | Q_Q(QBarCategoryAxis); | |
448 | if (m_orientation == Qt::Vertical) |
|
448 | if (m_orientation == Qt::Vertical) | |
@@ -450,7 +450,7 ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter) | |||||
450 | return new ChartBarCategoryAxisX(q, presenter); |
|
450 | return new ChartBarCategoryAxisX(q, presenter); | |
451 | } |
|
451 | } | |
452 |
|
452 | |||
453 |
void QBarCategoryAxisPrivate::intializeDomain(Domain* |
|
453 | void QBarCategoryAxisPrivate::intializeDomain(Domain *domain) | |
454 | { |
|
454 | { | |
455 |
|
455 | |||
456 | Q_Q(QBarCategoryAxis); |
|
456 | Q_Q(QBarCategoryAxis); |
@@ -55,11 +55,11 public: | |||||
55 | QString at(int index) const; |
|
55 | QString at(int index) const; | |
56 |
|
56 | |||
57 | //range handling |
|
57 | //range handling | |
58 |
void setMin(const QString& |
|
58 | void setMin(const QString &minCategory); | |
59 | QString min() const; |
|
59 | QString min() const; | |
60 |
void setMax(const QString& |
|
60 | void setMax(const QString &maxCategory); | |
61 | QString max() const; |
|
61 | QString max() const; | |
62 |
void setRange(const QString& |
|
62 | void setRange(const QString &minCategory, const QString &maxCategory); | |
63 |
|
63 | |||
64 | Q_SIGNALS: |
|
64 | Q_SIGNALS: | |
65 | void categoriesChanged(); |
|
65 | void categoriesChanged(); |
@@ -46,8 +46,8 public: | |||||
46 | ~QBarCategoryAxisPrivate(); |
|
46 | ~QBarCategoryAxisPrivate(); | |
47 |
|
47 | |||
48 | public: |
|
48 | public: | |
49 |
ChartAxis* |
|
49 | ChartAxis *createGraphics(ChartPresenter *presenter); | |
50 |
void intializeDomain(Domain* |
|
50 | void intializeDomain(Domain *domain); | |
51 | void handleDomainUpdated(); |
|
51 | void handleDomainUpdated(); | |
52 | qreal min() { return m_min; } |
|
52 | qreal min() { return m_min; } | |
53 | qreal max() { return m_max; } |
|
53 | qreal max() { return m_max; } |
@@ -88,15 +88,15 void ChartCategoryAxisX::updateGeometry() | |||||
88 | QRectF chartRect = presenter()->chartsGeometry(); |
|
88 | QRectF chartRect = presenter()->chartsGeometry(); | |
89 | // axis base line |
|
89 | // axis base line | |
90 |
|
90 | |||
91 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
91 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
92 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); |
|
92 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); | |
93 |
|
93 | |||
94 | for (int i = 0; i < layout.size(); ++i) { |
|
94 | for (int i = 0; i < layout.size(); ++i) { | |
95 |
|
95 | |||
96 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
96 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
97 | if (i < ticksList.count()) |
|
97 | if (i < ticksList.count()) | |
98 | labelItem->setText(ticksList.at(i)); |
|
98 | labelItem->setText(ticksList.at(i)); | |
99 |
const QRectF& |
|
99 | const QRectF &rect = labelItem->boundingRect(); | |
100 | QPointF center = rect.center(); |
|
100 | QPointF center = rect.center(); | |
101 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
101 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
102 |
|
102 | |||
@@ -112,16 +112,16 void ChartCategoryAxisX::updateGeometry() | |||||
112 | labelItem->setVisible(true); |
|
112 | labelItem->setVisible(true); | |
113 |
|
113 | |||
114 | if ((i + 1) % 2 && i > 1) { |
|
114 | if ((i + 1) % 2 && i > 1) { | |
115 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
115 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
116 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); |
|
116 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); | |
117 | } |
|
117 | } | |
118 |
|
118 | |||
119 | // grid lines and axis line ticks |
|
119 | // grid lines and axis line ticks | |
120 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
120 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
121 | lineItem->setPos(layout[i], chartRect.top()); |
|
121 | lineItem->setPos(layout[i], chartRect.top()); | |
122 | lineItem->setLine(0, 0, 0, chartRect.height()); |
|
122 | lineItem->setLine(0, 0, 0, chartRect.height()); | |
123 |
|
123 | |||
124 | QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
124 | QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
125 | tickLineItem->setPos(layout[i], chartRect.bottom()); |
|
125 | tickLineItem->setPos(layout[i], chartRect.bottom()); | |
126 | tickLineItem->setLine(0, 0, 0, 5); |
|
126 | tickLineItem->setLine(0, 0, 0, 5); | |
127 |
|
127 | |||
@@ -142,7 +142,7 void ChartCategoryAxisX::handleAxisUpdated() | |||||
142 | ChartAxis::handleAxisUpdated(); |
|
142 | ChartAxis::handleAxisUpdated(); | |
143 | } |
|
143 | } | |
144 |
|
144 | |||
145 |
QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& |
|
145 | QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
146 | { |
|
146 | { | |
147 | Q_UNUSED(constraint) |
|
147 | Q_UNUSED(constraint) | |
148 |
|
148 |
@@ -44,7 +44,7 public: | |||||
44 | ~ChartCategoryAxisX(); |
|
44 | ~ChartCategoryAxisX(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return X_AXIS; } |
|
46 | AxisType axisType() const { return X_AXIS; } | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
48 | protected: |
|
48 | protected: | |
49 | QVector<qreal> calculateLayout() const; |
|
49 | QVector<qreal> calculateLayout() const; | |
50 | void updateGeometry(); |
|
50 | void updateGeometry(); |
@@ -90,17 +90,17 void ChartCategoryAxisY::updateGeometry() | |||||
90 | QRectF chartRect = presenter()->chartsGeometry(); |
|
90 | QRectF chartRect = presenter()->chartsGeometry(); | |
91 |
|
91 | |||
92 | // axis base line |
|
92 | // axis base line | |
93 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
93 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
94 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); |
|
94 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); | |
95 |
|
95 | |||
96 | for (int i = 0; i < layout.size(); ++i) { |
|
96 | for (int i = 0; i < layout.size(); ++i) { | |
97 |
|
97 | |||
98 | // label items |
|
98 | // label items | |
99 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
99 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
100 | if (i < ticksList.count()) { |
|
100 | if (i < ticksList.count()) { | |
101 | labelItem->setText(ticksList.at(i)); |
|
101 | labelItem->setText(ticksList.at(i)); | |
102 | } |
|
102 | } | |
103 |
const QRectF& |
|
103 | const QRectF &rect = labelItem->boundingRect(); | |
104 |
|
104 | |||
105 | QPointF center = rect.center(); |
|
105 | QPointF center = rect.center(); | |
106 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
106 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
@@ -118,16 +118,16 void ChartCategoryAxisY::updateGeometry() | |||||
118 | labelItem->setVisible(true); |
|
118 | labelItem->setVisible(true); | |
119 |
|
119 | |||
120 | if ((i + 1) % 2 && i > 1) { |
|
120 | if ((i + 1) % 2 && i > 1) { | |
121 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
121 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
122 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); |
|
122 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); | |
123 | } |
|
123 | } | |
124 |
|
124 | |||
125 | // grid lines and axis line ticks |
|
125 | // grid lines and axis line ticks | |
126 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
126 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
127 | lineItem->setPos(chartRect.left(), layout[i]); |
|
127 | lineItem->setPos(chartRect.left(), layout[i]); | |
128 | lineItem->setLine(0, 0, chartRect.width(), 0); |
|
128 | lineItem->setLine(0, 0, chartRect.width(), 0); | |
129 |
|
129 | |||
130 | QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
130 | QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
131 | tickLineItem->setPos(chartRect.left(), layout[i]); |
|
131 | tickLineItem->setPos(chartRect.left(), layout[i]); | |
132 | tickLineItem->setLine(-5, 0, 0, 0); |
|
132 | tickLineItem->setLine(-5, 0, 0, 0); | |
133 |
|
133 | |||
@@ -148,7 +148,7 void ChartCategoryAxisY::handleAxisUpdated() | |||||
148 | ChartAxis::handleAxisUpdated(); |
|
148 | ChartAxis::handleAxisUpdated(); | |
149 | } |
|
149 | } | |
150 |
|
150 | |||
151 |
QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& |
|
151 | QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
152 | { |
|
152 | { | |
153 | Q_UNUSED(constraint) |
|
153 | Q_UNUSED(constraint) | |
154 |
|
154 |
@@ -44,7 +44,7 public: | |||||
44 | ~ChartCategoryAxisY(); |
|
44 | ~ChartCategoryAxisY(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return Y_AXIS; } |
|
46 | AxisType axisType() const { return Y_AXIS; } | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
48 | protected: |
|
48 | protected: | |
49 | QVector<qreal> calculateLayout() const; |
|
49 | QVector<qreal> calculateLayout() const; | |
50 | void updateGeometry(); |
|
50 | void updateGeometry(); |
@@ -111,7 +111,7 QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d, QObject *parent): QValueAx | |||||
111 | It has to be greater than the high end limit of the previous category. |
|
111 | It has to be greater than the high end limit of the previous category. | |
112 | Otherwise the method returns without adding a new category. |
|
112 | Otherwise the method returns without adding a new category. | |
113 | */ |
|
113 | */ | |
114 |
void QCategoryAxis::append(const QString& |
|
114 | void QCategoryAxis::append(const QString &categoryLabel, qreal categoryEndValue) | |
115 | { |
|
115 | { | |
116 | Q_D(QCategoryAxis); |
|
116 | Q_D(QCategoryAxis); | |
117 |
|
117 | |||
@@ -148,7 +148,7 void QCategoryAxis::setStartValue(qreal min) | |||||
148 | /*! |
|
148 | /*! | |
149 | Returns the low end limit of the category specified by an \a categoryLabel |
|
149 | Returns the low end limit of the category specified by an \a categoryLabel | |
150 | */ |
|
150 | */ | |
151 |
qreal QCategoryAxis::startValue(const QString& |
|
151 | qreal QCategoryAxis::startValue(const QString &categoryLabel) const | |
152 | { |
|
152 | { | |
153 | Q_D(const QCategoryAxis); |
|
153 | Q_D(const QCategoryAxis); | |
154 | if (categoryLabel.isEmpty()) |
|
154 | if (categoryLabel.isEmpty()) | |
@@ -159,7 +159,7 qreal QCategoryAxis::startValue(const QString& categoryLabel) const | |||||
159 | /*! |
|
159 | /*! | |
160 | Returns the high end limit of the interval specified by an \a categoryLabel |
|
160 | Returns the high end limit of the interval specified by an \a categoryLabel | |
161 | */ |
|
161 | */ | |
162 |
qreal QCategoryAxis::endValue(const QString& |
|
162 | qreal QCategoryAxis::endValue(const QString &categoryLabel) const | |
163 | { |
|
163 | { | |
164 | Q_D(const QCategoryAxis); |
|
164 | Q_D(const QCategoryAxis); | |
165 | return d->m_categoriesMap.value(categoryLabel).second; |
|
165 | return d->m_categoriesMap.value(categoryLabel).second; | |
@@ -209,7 +209,7 void QCategoryAxis::remove(const QString &categoryLabel) | |||||
209 | Replaces \a oldLabel of an existing category with a \a newLabel |
|
209 | Replaces \a oldLabel of an existing category with a \a newLabel | |
210 | If the old label does not exist the method returns without making any changes. |
|
210 | If the old label does not exist the method returns without making any changes. | |
211 | */ |
|
211 | */ | |
212 |
void QCategoryAxis::replaceLabel(const QString& |
|
212 | void QCategoryAxis::replaceLabel(const QString &oldLabel, const QString &newLabel) | |
213 | { |
|
213 | { | |
214 | Q_D(QCategoryAxis); |
|
214 | Q_D(QCategoryAxis); | |
215 | int labelIndex = d->m_categories.indexOf(oldLabel); |
|
215 | int labelIndex = d->m_categories.indexOf(oldLabel); | |
@@ -252,9 +252,9 QAbstractAxis::AxisType QCategoryAxis::type() const | |||||
252 |
|
252 | |||
253 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
253 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
254 |
|
254 | |||
255 |
QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis* |
|
255 | QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis *q) | |
256 | QValueAxisPrivate(q), |
|
256 | : QValueAxisPrivate(q), | |
257 | m_categoryMinimum(0) |
|
257 | m_categoryMinimum(0) | |
258 | { |
|
258 | { | |
259 |
|
259 | |||
260 | } |
|
260 | } | |
@@ -276,7 +276,7 void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max, int coun | |||||
276 | Q_UNUSED(max); |
|
276 | Q_UNUSED(max); | |
277 | } |
|
277 | } | |
278 |
|
278 | |||
279 |
ChartAxis* |
|
279 | ChartAxis *QCategoryAxisPrivate::createGraphics(ChartPresenter *presenter) | |
280 | { |
|
280 | { | |
281 | Q_Q(QCategoryAxis); |
|
281 | Q_Q(QCategoryAxis); | |
282 | if (m_orientation == Qt::Vertical) |
|
282 | if (m_orientation == Qt::Vertical) |
@@ -43,14 +43,14 protected: | |||||
43 | public: |
|
43 | public: | |
44 | AxisType type() const; |
|
44 | AxisType type() const; | |
45 |
|
45 | |||
46 |
void append(const QString& |
|
46 | void append(const QString &label, qreal categoryEndValue); | |
47 |
void remove(const QString& |
|
47 | void remove(const QString &label); | |
48 |
void replaceLabel(const QString& |
|
48 | void replaceLabel(const QString &oldLabel, const QString &newLabel); | |
49 |
|
49 | |||
50 |
qreal startValue(const QString& |
|
50 | qreal startValue(const QString &categoryLabel = QString()) const; | |
51 | void setStartValue(qreal min); |
|
51 | void setStartValue(qreal min); | |
52 |
|
52 | |||
53 |
qreal endValue(const QString& |
|
53 | qreal endValue(const QString &categoryLabel) const; | |
54 |
|
54 | |||
55 | QStringList categoriesLabels(); |
|
55 | QStringList categoriesLabels(); | |
56 | int count() const; |
|
56 | int count() const; |
@@ -45,7 +45,7 public: | |||||
45 | QCategoryAxisPrivate(QCategoryAxis *q); |
|
45 | QCategoryAxisPrivate(QCategoryAxis *q); | |
46 | ~QCategoryAxisPrivate(); |
|
46 | ~QCategoryAxisPrivate(); | |
47 |
|
47 | |||
48 |
ChartAxis* |
|
48 | ChartAxis *createGraphics(ChartPresenter *presenter); | |
49 | int ticksCount() const; |
|
49 | int ticksCount() const; | |
50 |
|
50 | |||
51 | Q_SIGNALS: |
|
51 | Q_SIGNALS: |
@@ -62,7 +62,7 ChartAxis::~ChartAxis() | |||||
62 | { |
|
62 | { | |
63 | } |
|
63 | } | |
64 |
|
64 | |||
65 |
void ChartAxis::setAnimation(AxisAnimation* |
|
65 | void ChartAxis::setAnimation(AxisAnimation *animation) | |
66 | { |
|
66 | { | |
67 | m_animation = animation; |
|
67 | m_animation = animation; | |
68 | } |
|
68 | } | |
@@ -271,7 +271,7 bool ChartAxis::isEmpty() | |||||
271 |
|
271 | |||
272 | void ChartAxis::handleDomainUpdated() |
|
272 | void ChartAxis::handleDomainUpdated() | |
273 | { |
|
273 | { | |
274 |
Domain* |
|
274 | Domain *domain = qobject_cast<Domain *>(sender()); | |
275 | qreal min(0); |
|
275 | qreal min(0); | |
276 | qreal max(0); |
|
276 | qreal max(0); | |
277 |
|
277 | |||
@@ -328,7 +328,7 void ChartAxis::handleAxisUpdated() | |||||
328 | setTitleText(m_chartAxis->title()); |
|
328 | setTitleText(m_chartAxis->title()); | |
329 | } |
|
329 | } | |
330 |
|
330 | |||
331 |
void ChartAxis::setTitleText(const QString& |
|
331 | void ChartAxis::setTitleText(const QString &title) | |
332 | { |
|
332 | { | |
333 | if (m_titleText != title) { |
|
333 | if (m_titleText != title) { | |
334 | m_titleText = title; |
|
334 | m_titleText = title; | |
@@ -444,9 +444,8 bool ChartAxis::isVisible() | |||||
444 | return m_chartAxis->isVisible(); |
|
444 | return m_chartAxis->isVisible(); | |
445 | } |
|
445 | } | |
446 |
|
446 | |||
447 |
QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF& |
|
447 | QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
448 | { |
|
448 | { | |
449 |
|
||||
450 | Q_UNUSED(constraint); |
|
449 | Q_UNUSED(constraint); | |
451 | QFontMetrics fn(m_title->font()); |
|
450 | QFontMetrics fn(m_title->font()); | |
452 | QSizeF sh; |
|
451 | QSizeF sh; |
@@ -86,14 +86,14 public: | |||||
86 | void setTitlePen(const QPen &pen); |
|
86 | void setTitlePen(const QPen &pen); | |
87 | void setTitleBrush(const QBrush &brush); |
|
87 | void setTitleBrush(const QBrush &brush); | |
88 | void setTitleFont(const QFont &font); |
|
88 | void setTitleFont(const QFont &font); | |
89 |
void setTitleText(const QString& |
|
89 | void setTitleText(const QString &title); | |
90 |
|
90 | |||
91 |
|
91 | |||
92 | void setLayout(QVector<qreal> &layout); |
|
92 | void setLayout(QVector<qreal> &layout); | |
93 | QVector<qreal> layout() const { return m_layoutVector; } |
|
93 | QVector<qreal> layout() const { return m_layoutVector; } | |
94 |
|
94 | |||
95 |
void setAnimation(AxisAnimation* |
|
95 | void setAnimation(AxisAnimation *animation); | |
96 |
ChartAnimation* |
|
96 | ChartAnimation *animation() const { return m_animation; }; | |
97 |
|
97 | |||
98 | Qt::Orientation orientation() const; |
|
98 | Qt::Orientation orientation() const; | |
99 | bool alternativePlacement() const; |
|
99 | bool alternativePlacement() const; | |
@@ -106,7 +106,7 public: | |||||
106 |
|
106 | |||
107 | void setInternalRect(const QRectF &size); |
|
107 | void setInternalRect(const QRectF &size); | |
108 |
|
108 | |||
109 |
virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
109 | virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const; | |
110 |
|
110 | |||
111 | protected: |
|
111 | protected: | |
112 | virtual void updateGeometry() = 0; |
|
112 | virtual void updateGeometry() = 0; | |
@@ -127,7 +127,7 private: | |||||
127 | void axisSelected(); |
|
127 | void axisSelected(); | |
128 |
|
128 | |||
129 | protected: |
|
129 | protected: | |
130 |
QAbstractAxis* |
|
130 | QAbstractAxis *m_chartAxis; | |
131 | int m_labelsAngle; |
|
131 | int m_labelsAngle; | |
132 | //TODO: to be removed |
|
132 | //TODO: to be removed | |
133 | QRectF m_rect; |
|
133 | QRectF m_rect; | |
@@ -136,7 +136,7 protected: | |||||
136 | QScopedPointer<QGraphicsItemGroup> m_shades; |
|
136 | QScopedPointer<QGraphicsItemGroup> m_shades; | |
137 | QScopedPointer<QGraphicsItemGroup> m_labels; |
|
137 | QScopedPointer<QGraphicsItemGroup> m_labels; | |
138 | QScopedPointer<QGraphicsItemGroup> m_arrow; |
|
138 | QScopedPointer<QGraphicsItemGroup> m_arrow; | |
139 |
QGraphicsSimpleTextItem* |
|
139 | QGraphicsSimpleTextItem *m_title; | |
140 | QVector<qreal> m_layoutVector; |
|
140 | QVector<qreal> m_layoutVector; | |
141 | qreal m_min; |
|
141 | qreal m_min; | |
142 | qreal m_max; |
|
142 | qreal m_max; | |
@@ -173,7 +173,7 protected: | |||||
173 | } |
|
173 | } | |
174 |
|
174 | |||
175 | private: |
|
175 | private: | |
176 |
ChartAxis* |
|
176 | ChartAxis *m_axis; | |
177 | }; |
|
177 | }; | |
178 |
|
178 | |||
179 | QTCOMMERCIALCHART_END_NAMESPACE |
|
179 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -92,16 +92,16 void ChartDateTimeAxisX::updateGeometry() | |||||
92 |
|
92 | |||
93 | QRectF chartRect = presenter()->chartsGeometry(); |
|
93 | QRectF chartRect = presenter()->chartsGeometry(); | |
94 |
|
94 | |||
95 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
95 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
96 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); |
|
96 | lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom()); | |
97 |
|
97 | |||
98 | qreal width = 0; |
|
98 | qreal width = 0; | |
99 | for (int i = 0; i < layout.size(); ++i) { |
|
99 | for (int i = 0; i < layout.size(); ++i) { | |
100 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
100 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
101 | lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom()); |
|
101 | lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom()); | |
102 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
102 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
103 | labelItem->setText(ticksList.at(i)); |
|
103 | labelItem->setText(ticksList.at(i)); | |
104 |
const QRectF& |
|
104 | const QRectF &rect = labelItem->boundingRect(); | |
105 | QPointF center = rect.center(); |
|
105 | QPointF center = rect.center(); | |
106 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
106 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
107 | labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding); |
|
107 | labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding); | |
@@ -116,10 +116,10 void ChartDateTimeAxisX::updateGeometry() | |||||
116 | } |
|
116 | } | |
117 |
|
117 | |||
118 | if ((i + 1) % 2 && i > 1) { |
|
118 | if ((i + 1) % 2 && i > 1) { | |
119 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
119 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
120 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); |
|
120 | rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height()); | |
121 | } |
|
121 | } | |
122 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
122 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
123 | lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5); |
|
123 | lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5); | |
124 | } |
|
124 | } | |
125 | } |
|
125 | } | |
@@ -127,12 +127,12 void ChartDateTimeAxisX::updateGeometry() | |||||
127 | void ChartDateTimeAxisX::handleAxisUpdated() |
|
127 | void ChartDateTimeAxisX::handleAxisUpdated() | |
128 | { |
|
128 | { | |
129 | //TODO:: fix this |
|
129 | //TODO:: fix this | |
130 |
QDateTimeAxis* |
|
130 | QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis); | |
131 | m_tickCount = axis->tickCount(); |
|
131 | m_tickCount = axis->tickCount(); | |
132 | ChartAxis::handleAxisUpdated(); |
|
132 | ChartAxis::handleAxisUpdated(); | |
133 | } |
|
133 | } | |
134 |
|
134 | |||
135 |
QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF& |
|
135 | QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
136 | { |
|
136 | { | |
137 | Q_UNUSED(constraint) |
|
137 | Q_UNUSED(constraint) | |
138 |
|
138 | |||
@@ -157,7 +157,7 QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint | |||||
157 | } |
|
157 | } | |
158 | sh = QSizeF(width, height); |
|
158 | sh = QSizeF(width, height); | |
159 | break; |
|
159 | break; | |
160 |
|
|
160 | } | |
161 | default: |
|
161 | default: | |
162 | break; |
|
162 | break; | |
163 | } |
|
163 | } |
@@ -44,7 +44,7 public: | |||||
44 | ~ChartDateTimeAxisX(); |
|
44 | ~ChartDateTimeAxisX(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return X_AXIS;} |
|
46 | AxisType axisType() const { return X_AXIS;} | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
48 | protected: |
|
48 | protected: | |
49 | void createLabels(QStringList &labels, qreal min, qreal max, int ticks); |
|
49 | void createLabels(QStringList &labels, qreal min, qreal max, int ticks); | |
50 | void handleAxisUpdated(); |
|
50 | void handleAxisUpdated(); |
@@ -95,16 +95,16 void ChartDateTimeAxisY::updateGeometry() | |||||
95 |
|
95 | |||
96 | qreal height = chartRect.bottom(); |
|
96 | qreal height = chartRect.bottom(); | |
97 |
|
97 | |||
98 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
98 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
99 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); |
|
99 | lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); | |
100 |
|
100 | |||
101 | for (int i = 0; i < layout.size(); ++i) { |
|
101 | for (int i = 0; i < layout.size(); ++i) { | |
102 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
102 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
103 | lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]); |
|
103 | lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]); | |
104 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
104 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
105 |
|
105 | |||
106 | labelItem->setText(ticksList.at(i)); |
|
106 | labelItem->setText(ticksList.at(i)); | |
107 |
const QRectF& |
|
107 | const QRectF &rect = labelItem->boundingRect(); | |
108 |
|
108 | |||
109 | QPointF center = rect.center(); |
|
109 | QPointF center = rect.center(); | |
110 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
110 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
@@ -120,10 +120,10 void ChartDateTimeAxisY::updateGeometry() | |||||
120 | } |
|
120 | } | |
121 |
|
121 | |||
122 | if ((i + 1) % 2 && i > 1) { |
|
122 | if ((i + 1) % 2 && i > 1) { | |
123 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
123 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
124 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); |
|
124 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); | |
125 | } |
|
125 | } | |
126 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
126 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
127 | lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]); |
|
127 | lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]); | |
128 | } |
|
128 | } | |
129 | } |
|
129 | } | |
@@ -131,12 +131,12 void ChartDateTimeAxisY::updateGeometry() | |||||
131 | void ChartDateTimeAxisY::handleAxisUpdated() |
|
131 | void ChartDateTimeAxisY::handleAxisUpdated() | |
132 | { |
|
132 | { | |
133 | //TODO:: fix this |
|
133 | //TODO:: fix this | |
134 |
QDateTimeAxis* |
|
134 | QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis); | |
135 | m_tickCount = axis->tickCount(); |
|
135 | m_tickCount = axis->tickCount(); | |
136 | ChartAxis::handleAxisUpdated(); |
|
136 | ChartAxis::handleAxisUpdated(); | |
137 | } |
|
137 | } | |
138 |
|
138 | |||
139 |
QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF& |
|
139 | QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
140 | { |
|
140 | { | |
141 | Q_UNUSED(constraint) |
|
141 | Q_UNUSED(constraint) | |
142 |
|
142 |
@@ -44,7 +44,7 public: | |||||
44 | ~ChartDateTimeAxisY(); |
|
44 | ~ChartDateTimeAxisY(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return Y_AXIS;} |
|
46 | AxisType axisType() const { return Y_AXIS;} | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
48 | protected: |
|
48 | protected: | |
49 | void createLabels(QStringList &labels, qreal min, qreal max, int ticks); |
|
49 | void createLabels(QStringList &labels, qreal min, qreal max, int ticks); | |
50 | QVector<qreal> calculateLayout() const; |
|
50 | QVector<qreal> calculateLayout() const; |
@@ -281,11 +281,11 QAbstractAxis::AxisType QDateTimeAxis::type() const | |||||
281 |
|
281 | |||
282 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
282 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
283 |
|
283 | |||
284 |
QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis* |
|
284 | QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis *q) | |
285 | QAbstractAxisPrivate(q), |
|
285 | : QAbstractAxisPrivate(q), | |
286 | m_min(QDateTime::fromMSecsSinceEpoch(0)), |
|
286 | m_min(QDateTime::fromMSecsSinceEpoch(0)), | |
287 | m_max(QDateTime::fromMSecsSinceEpoch(0)), |
|
287 | m_max(QDateTime::fromMSecsSinceEpoch(0)), | |
288 | m_tickCount(5) |
|
288 | m_tickCount(5) | |
289 | { |
|
289 | { | |
290 | m_format = "dd-MM-yyyy\nh:mm"; |
|
290 | m_format = "dd-MM-yyyy\nh:mm"; | |
291 | } |
|
291 | } | |
@@ -298,7 +298,7 QDateTimeAxisPrivate::~QDateTimeAxisPrivate() | |||||
298 | void QDateTimeAxisPrivate::handleDomainUpdated() |
|
298 | void QDateTimeAxisPrivate::handleDomainUpdated() | |
299 | { |
|
299 | { | |
300 | Q_Q(QDateTimeAxis); |
|
300 | Q_Q(QDateTimeAxis); | |
301 |
Domain* |
|
301 | Domain *domain = qobject_cast<Domain *>(sender()); | |
302 | Q_ASSERT(domain); |
|
302 | Q_ASSERT(domain); | |
303 |
|
303 | |||
304 | if (orientation() == Qt::Horizontal) |
|
304 | if (orientation() == Qt::Horizontal) | |
@@ -330,7 +330,7 void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max) | |||||
330 | q->setRange(min.toDateTime(), max.toDateTime()); |
|
330 | q->setRange(min.toDateTime(), max.toDateTime()); | |
331 | } |
|
331 | } | |
332 |
|
332 | |||
333 |
ChartAxis* |
|
333 | ChartAxis *QDateTimeAxisPrivate::createGraphics(ChartPresenter *presenter) | |
334 | { |
|
334 | { | |
335 | Q_Q(QDateTimeAxis); |
|
335 | Q_Q(QDateTimeAxis); | |
336 | if (m_orientation == Qt::Vertical) |
|
336 | if (m_orientation == Qt::Vertical) | |
@@ -338,7 +338,7 ChartAxis* QDateTimeAxisPrivate::createGraphics(ChartPresenter* presenter) | |||||
338 | return new ChartDateTimeAxisX(q, presenter); |
|
338 | return new ChartDateTimeAxisX(q, presenter); | |
339 | } |
|
339 | } | |
340 |
|
340 | |||
341 |
void QDateTimeAxisPrivate::intializeDomain(Domain* |
|
341 | void QDateTimeAxisPrivate::intializeDomain(Domain *domain) | |
342 | { |
|
342 | { | |
343 | Q_Q(QDateTimeAxis); |
|
343 | Q_Q(QDateTimeAxis); | |
344 | if (m_max == m_min) { |
|
344 | if (m_max == m_min) { |
@@ -44,11 +44,11 public: | |||||
44 | ~QDateTimeAxisPrivate(); |
|
44 | ~QDateTimeAxisPrivate(); | |
45 |
|
45 | |||
46 | public: |
|
46 | public: | |
47 |
ChartAxis* |
|
47 | ChartAxis *createGraphics(ChartPresenter *presenter); | |
48 |
void intializeDomain(Domain* |
|
48 | void intializeDomain(Domain *domain); | |
49 | void handleDomainUpdated(); |
|
49 | void handleDomainUpdated(); | |
50 | qreal min(){ return m_min.toMSecsSinceEpoch(); } |
|
50 | qreal min() { return m_min.toMSecsSinceEpoch(); } | |
51 | qreal max(){ return m_max.toMSecsSinceEpoch(); } |
|
51 | qreal max() { return m_max.toMSecsSinceEpoch(); } | |
52 | int count() const { /*TODO:*/ return 0;} |
|
52 | int count() const { /*TODO:*/ return 0;} | |
53 |
|
53 | |||
54 | protected: |
|
54 | protected: |
@@ -529,7 +529,7 QFont QAbstractAxis::titleFont() const | |||||
529 | return d_ptr->m_titleFont; |
|
529 | return d_ptr->m_titleFont; | |
530 | } |
|
530 | } | |
531 |
|
531 | |||
532 |
void QAbstractAxis::setTitle(const QString& |
|
532 | void QAbstractAxis::setTitle(const QString &title) | |
533 | { |
|
533 | { | |
534 | if (d_ptr->m_title != title) { |
|
534 | if (d_ptr->m_title != title) { | |
535 | d_ptr->m_title = title; |
|
535 | d_ptr->m_title = title; | |
@@ -706,20 +706,20 void QAbstractAxis::setAlternativePlacement(bool placement) | |||||
706 |
|
706 | |||
707 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
707 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
708 |
|
708 | |||
709 |
QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* |
|
709 | QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q) | |
710 | q_ptr(q), |
|
710 | : q_ptr(q), | |
711 | m_orientation(Qt::Orientation(0)), |
|
711 | m_orientation(Qt::Orientation(0)), | |
712 | m_dataset(0), |
|
712 | m_dataset(0), | |
713 | m_visible(true), |
|
713 | m_visible(true), | |
714 | m_arrowVisible(true), |
|
714 | m_arrowVisible(true), | |
715 | m_gridLineVisible(true), |
|
715 | m_gridLineVisible(true), | |
716 | m_labelsVisible(true), |
|
716 | m_labelsVisible(true), | |
717 | m_labelsAngle(0), |
|
717 | m_labelsAngle(0), | |
718 | m_shadesVisible(false), |
|
718 | m_shadesVisible(false), | |
719 | m_shadesBrush(Qt::SolidPattern), |
|
719 | m_shadesBrush(Qt::SolidPattern), | |
720 | m_shadesOpacity(1.0), |
|
720 | m_shadesOpacity(1.0), | |
721 | m_dirty(false), |
|
721 | m_dirty(false), | |
722 | m_alternativePlacement(false) |
|
722 | m_alternativePlacement(false) | |
723 | { |
|
723 | { | |
724 |
|
724 | |||
725 | } |
|
725 | } |
@@ -107,7 +107,7 public: | |||||
107 | QBrush titleBrush() const; |
|
107 | QBrush titleBrush() const; | |
108 | void setTitleFont(const QFont &font); |
|
108 | void setTitleFont(const QFont &font); | |
109 | QFont titleFont() const; |
|
109 | QFont titleFont() const; | |
110 |
void setTitle(const QString& |
|
110 | void setTitle(const QString &title); | |
111 | QString title() const; |
|
111 | QString title() const; | |
112 |
|
112 | |||
113 |
|
113 |
@@ -47,13 +47,12 public: | |||||
47 | ~QAbstractAxisPrivate(); |
|
47 | ~QAbstractAxisPrivate(); | |
48 |
|
48 | |||
49 | public: |
|
49 | public: | |
50 |
|
50 | virtual ChartAxis *createGraphics(ChartPresenter *presenter) = 0; | ||
51 | virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0; |
|
51 | virtual void intializeDomain(Domain *domain) = 0; | |
52 | virtual void intializeDomain(Domain* domain) = 0; |
|
|||
53 |
|
52 | |||
54 | void emitUpdated(); |
|
53 | void emitUpdated(); | |
55 | void setDirty(bool dirty); |
|
54 | void setDirty(bool dirty); | |
56 | bool isDirty(){ return m_dirty; } |
|
55 | bool isDirty() { return m_dirty; } | |
57 | void setOrientation(Qt::Orientation orientation); |
|
56 | void setOrientation(Qt::Orientation orientation); | |
58 | Qt::Orientation orientation() const { return m_orientation; } |
|
57 | Qt::Orientation orientation() const { return m_orientation; } | |
59 |
|
58 |
@@ -77,7 +77,7 void ChartValueAxisX::updateGeometry() | |||||
77 |
|
77 | |||
78 | QRectF chartRrect = presenter()->chartsGeometry(); |
|
78 | QRectF chartRrect = presenter()->chartsGeometry(); | |
79 |
|
79 | |||
80 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
80 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
81 | // lineItem->setLine(chartRrect.left(), chartRrect.bottom(), chartRrect.right(), chartRrect.bottom()); |
|
81 | // lineItem->setLine(chartRrect.left(), chartRrect.bottom(), chartRrect.right(), chartRrect.bottom()); | |
82 | if (m_chartAxis->alternativePlacement()) |
|
82 | if (m_chartAxis->alternativePlacement()) | |
83 | lineItem->setLine(chartRrect.left(), m_internalRect.top(), chartRrect.right(), m_internalRect.top()); |
|
83 | lineItem->setLine(chartRrect.left(), m_internalRect.top(), chartRrect.right(), m_internalRect.top()); | |
@@ -86,11 +86,11 void ChartValueAxisX::updateGeometry() | |||||
86 |
|
86 | |||
87 | qreal width = 0; |
|
87 | qreal width = 0; | |
88 | for (int i = 0; i < layout.size(); ++i) { |
|
88 | for (int i = 0; i < layout.size(); ++i) { | |
89 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
89 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
90 | lineItem->setLine(layout[i], chartRrect.top(), layout[i], chartRrect.bottom()); |
|
90 | lineItem->setLine(layout[i], chartRrect.top(), layout[i], chartRrect.bottom()); | |
91 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
91 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
92 | labelItem->setText(ticksList.at(i)); |
|
92 | labelItem->setText(ticksList.at(i)); | |
93 |
const QRectF& |
|
93 | const QRectF &rect = labelItem->boundingRect(); | |
94 | QPointF center = rect.center(); |
|
94 | QPointF center = rect.center(); | |
95 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
95 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
96 | // labelItem->setPos(layout[i] - center.x(), chartRrect.bottom() + label_padding); |
|
96 | // labelItem->setPos(layout[i] - center.x(), chartRrect.bottom() + label_padding); | |
@@ -100,7 +100,7 void ChartValueAxisX::updateGeometry() | |||||
100 | labelItem->setPos(layout[i] - center.x(), m_internalRect.bottom() + label_padding); |
|
100 | labelItem->setPos(layout[i] - center.x(), m_internalRect.bottom() + label_padding); | |
101 | if (labelItem->pos().x() <= width || |
|
101 | if (labelItem->pos().x() <= width || | |
102 | labelItem->pos().x() < m_rect.left() || |
|
102 | labelItem->pos().x() < m_rect.left() || | |
103 | labelItem->pos().x() + rect.width() > m_rect.right()){ |
|
103 | labelItem->pos().x() + rect.width() > m_rect.right()) { | |
104 | labelItem->setVisible(false); |
|
104 | labelItem->setVisible(false); | |
105 | lineItem->setVisible(false); |
|
105 | lineItem->setVisible(false); | |
106 | } else { |
|
106 | } else { | |
@@ -110,10 +110,10 void ChartValueAxisX::updateGeometry() | |||||
110 | } |
|
110 | } | |
111 |
|
111 | |||
112 | if ((i + 1) % 2 && i > 1) { |
|
112 | if ((i + 1) % 2 && i > 1) { | |
113 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
113 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
114 | rectItem->setRect(layout[i - 1], chartRrect.top(), layout[i] - layout[i - 1], chartRrect.height()); |
|
114 | rectItem->setRect(layout[i - 1], chartRrect.top(), layout[i] - layout[i - 1], chartRrect.height()); | |
115 | } |
|
115 | } | |
116 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
116 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
117 | // lineItem->setLine(layout[i],chartRrect.bottom(),layout[i],chartRrect.bottom()+5); |
|
117 | // lineItem->setLine(layout[i],chartRrect.bottom(),layout[i],chartRrect.bottom()+5); | |
118 | if (m_chartAxis->alternativePlacement()) |
|
118 | if (m_chartAxis->alternativePlacement()) | |
119 | lineItem->setLine(layout[i], m_internalRect.top(), layout[i], m_internalRect.top() - 5); |
|
119 | lineItem->setLine(layout[i], m_internalRect.top(), layout[i], m_internalRect.top() - 5); | |
@@ -125,7 +125,7 void ChartValueAxisX::updateGeometry() | |||||
125 | void ChartValueAxisX::handleAxisUpdated() |
|
125 | void ChartValueAxisX::handleAxisUpdated() | |
126 | { |
|
126 | { | |
127 | //TODO:: fix this |
|
127 | //TODO:: fix this | |
128 |
QValueAxis* |
|
128 | QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis); | |
129 | if (m_tickCount != axis->tickCount()) { |
|
129 | if (m_tickCount != axis->tickCount()) { | |
130 | m_tickCount = axis->tickCount(); |
|
130 | m_tickCount = axis->tickCount(); | |
131 | presenter()->layout()->invalidate(); |
|
131 | presenter()->layout()->invalidate(); | |
@@ -133,7 +133,7 void ChartValueAxisX::handleAxisUpdated() | |||||
133 | ChartAxis::handleAxisUpdated(); |
|
133 | ChartAxis::handleAxisUpdated(); | |
134 | } |
|
134 | } | |
135 |
|
135 | |||
136 |
QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF& |
|
136 | QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
137 | { |
|
137 | { | |
138 | Q_UNUSED(constraint) |
|
138 | Q_UNUSED(constraint) | |
139 |
|
139 |
@@ -44,7 +44,8 public: | |||||
44 | ~ChartValueAxisX(); |
|
44 | ~ChartValueAxisX(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return X_AXIS;} |
|
46 | AxisType axisType() const { return X_AXIS;} | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
|
48 | ||||
48 | protected: |
|
49 | protected: | |
49 | void handleAxisUpdated(); |
|
50 | void handleAxisUpdated(); | |
50 | QVector<qreal> calculateLayout() const; |
|
51 | QVector<qreal> calculateLayout() const; |
@@ -80,7 +80,7 void ChartValueAxisY::updateGeometry() | |||||
80 |
|
80 | |||
81 | qreal height = m_rect.bottom(); |
|
81 | qreal height = m_rect.bottom(); | |
82 |
|
82 | |||
83 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); |
|
83 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0)); | |
84 | // lineItem->setLine( chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); |
|
84 | // lineItem->setLine( chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom()); | |
85 | if (m_chartAxis->alternativePlacement()) |
|
85 | if (m_chartAxis->alternativePlacement()) | |
86 | lineItem->setLine(m_internalRect.right(), chartRect.top(), m_internalRect.right(), chartRect.bottom()); |
|
86 | lineItem->setLine(m_internalRect.right(), chartRect.top(), m_internalRect.right(), chartRect.bottom()); | |
@@ -90,9 +90,9 void ChartValueAxisY::updateGeometry() | |||||
90 | QFontMetrics fn(m_font); |
|
90 | QFontMetrics fn(m_font); | |
91 |
|
91 | |||
92 | for (int i = 0; i < layout.size(); ++i) { |
|
92 | for (int i = 0; i < layout.size(); ++i) { | |
93 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); |
|
93 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i)); | |
94 | lineItem->setLine(chartRect.left(), layout[i], chartRect.right(), layout[i]); |
|
94 | lineItem->setLine(chartRect.left(), layout[i], chartRect.right(), layout[i]); | |
95 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); |
|
95 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i)); | |
96 |
|
96 | |||
97 | QString text = ticksList.at(i); |
|
97 | QString text = ticksList.at(i); | |
98 |
|
98 | |||
@@ -105,7 +105,7 void ChartValueAxisY::updateGeometry() | |||||
105 | labelItem->setText(text); |
|
105 | labelItem->setText(text); | |
106 | } |
|
106 | } | |
107 |
|
107 | |||
108 |
const QRectF& |
|
108 | const QRectF &rect = labelItem->boundingRect(); | |
109 |
|
109 | |||
110 | QPointF center = rect.center(); |
|
110 | QPointF center = rect.center(); | |
111 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
111 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
@@ -126,10 +126,10 void ChartValueAxisY::updateGeometry() | |||||
126 | } |
|
126 | } | |
127 |
|
127 | |||
128 | if ((i + 1) % 2 && i > 1) { |
|
128 | if ((i + 1) % 2 && i > 1) { | |
129 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1)); |
|
129 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1)); | |
130 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); |
|
130 | rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]); | |
131 | } |
|
131 | } | |
132 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1)); |
|
132 | lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1)); | |
133 | // lineItem->setLine( chartRect.left()-5,layout[i], chartRect.left(),layout[i]); |
|
133 | // lineItem->setLine( chartRect.left()-5,layout[i], chartRect.left(),layout[i]); | |
134 | if (m_chartAxis->alternativePlacement()) |
|
134 | if (m_chartAxis->alternativePlacement()) | |
135 | lineItem->setLine(m_internalRect.right() + 5, layout[i], m_internalRect.right(), layout[i]); |
|
135 | lineItem->setLine(m_internalRect.right() + 5, layout[i], m_internalRect.right(), layout[i]); | |
@@ -141,7 +141,7 void ChartValueAxisY::updateGeometry() | |||||
141 | void ChartValueAxisY::handleAxisUpdated() |
|
141 | void ChartValueAxisY::handleAxisUpdated() | |
142 | { |
|
142 | { | |
143 | //TODO:: fix this |
|
143 | //TODO:: fix this | |
144 |
QValueAxis* |
|
144 | QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis); | |
145 | if (m_tickCount != axis->tickCount()) { |
|
145 | if (m_tickCount != axis->tickCount()) { | |
146 | m_tickCount = axis->tickCount(); |
|
146 | m_tickCount = axis->tickCount(); | |
147 | presenter()->layout()->invalidate(); |
|
147 | presenter()->layout()->invalidate(); | |
@@ -149,7 +149,7 void ChartValueAxisY::handleAxisUpdated() | |||||
149 | ChartAxis::handleAxisUpdated(); |
|
149 | ChartAxis::handleAxisUpdated(); | |
150 | } |
|
150 | } | |
151 |
|
151 | |||
152 |
QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF& |
|
152 | QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
153 | { |
|
153 | { | |
154 | Q_UNUSED(constraint) |
|
154 | Q_UNUSED(constraint) | |
155 |
|
155 |
@@ -44,7 +44,7 public: | |||||
44 | ~ChartValueAxisY(); |
|
44 | ~ChartValueAxisY(); | |
45 |
|
45 | |||
46 | AxisType axisType() const { return Y_AXIS;} |
|
46 | AxisType axisType() const { return Y_AXIS;} | |
47 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
47 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
48 | protected: |
|
48 | protected: | |
49 | QVector<qreal> calculateLayout() const; |
|
49 | QVector<qreal> calculateLayout() const; | |
50 | void updateGeometry(); |
|
50 | void updateGeometry(); |
@@ -297,13 +297,13 QAbstractAxis::AxisType QValueAxis::type() const | |||||
297 |
|
297 | |||
298 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
298 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
299 |
|
299 | |||
300 |
QValueAxisPrivate::QValueAxisPrivate(QValueAxis* |
|
300 | QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q) | |
301 | QAbstractAxisPrivate(q), |
|
301 | : QAbstractAxisPrivate(q), | |
302 | m_min(0), |
|
302 | m_min(0), | |
303 | m_max(0), |
|
303 | m_max(0), | |
304 | m_tickCount(5), |
|
304 | m_tickCount(5), | |
305 | m_niceNumbers(false), |
|
305 | m_niceNumbers(false), | |
306 | m_format(QString::null) |
|
306 | m_format(QString::null) | |
307 | { |
|
307 | { | |
308 |
|
308 | |||
309 | } |
|
309 | } | |
@@ -316,7 +316,7 QValueAxisPrivate::~QValueAxisPrivate() | |||||
316 | void QValueAxisPrivate::handleDomainUpdated() |
|
316 | void QValueAxisPrivate::handleDomainUpdated() | |
317 | { |
|
317 | { | |
318 | Q_Q(QValueAxis); |
|
318 | Q_Q(QValueAxis); | |
319 |
Domain* |
|
319 | Domain *domain = qobject_cast<Domain *>(sender()); | |
320 | Q_ASSERT(domain); |
|
320 | Q_ASSERT(domain); | |
321 |
|
321 | |||
322 | if (orientation() == Qt::Horizontal) |
|
322 | if (orientation() == Qt::Horizontal) | |
@@ -356,7 +356,7 void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max) | |||||
356 | q->setRange(value1, value2); |
|
356 | q->setRange(value1, value2); | |
357 | } |
|
357 | } | |
358 |
|
358 | |||
359 |
ChartAxis* |
|
359 | ChartAxis *QValueAxisPrivate::createGraphics(ChartPresenter *presenter) | |
360 | { |
|
360 | { | |
361 | Q_Q(QValueAxis); |
|
361 | Q_Q(QValueAxis); | |
362 | if (m_orientation == Qt::Vertical) |
|
362 | if (m_orientation == Qt::Vertical) | |
@@ -364,7 +364,7 ChartAxis* QValueAxisPrivate::createGraphics(ChartPresenter* presenter) | |||||
364 | return new ChartValueAxisX(q, presenter); |
|
364 | return new ChartValueAxisX(q, presenter); | |
365 | } |
|
365 | } | |
366 |
|
366 | |||
367 |
void QValueAxisPrivate::intializeDomain(Domain* |
|
367 | void QValueAxisPrivate::intializeDomain(Domain *domain) | |
368 | { |
|
368 | { | |
369 | Q_Q(QValueAxis); |
|
369 | Q_Q(QValueAxis); | |
370 | if (qFuzzyCompare(m_max, m_min)) { |
|
370 | if (qFuzzyCompare(m_max, m_min)) { |
@@ -43,11 +43,11 public: | |||||
43 | ~QValueAxisPrivate(); |
|
43 | ~QValueAxisPrivate(); | |
44 |
|
44 | |||
45 | public: |
|
45 | public: | |
46 |
ChartAxis* |
|
46 | ChartAxis *createGraphics(ChartPresenter *presenter); | |
47 |
void intializeDomain(Domain* |
|
47 | void intializeDomain(Domain *domain); | |
48 | void handleDomainUpdated(); |
|
48 | void handleDomainUpdated(); | |
49 | qreal min(){ return m_min; }; |
|
49 | qreal min() { return m_min; }; | |
50 | qreal max(){ return m_max; }; |
|
50 | qreal max() { return m_max; }; | |
51 | int count() const { return m_tickCount; } |
|
51 | int count() const { return m_tickCount; } | |
52 |
|
52 | |||
53 | protected: |
|
53 | protected: |
@@ -184,13 +184,13 void AbstractBarChartItem::handleUpdatedBars() | |||||
184 |
|
184 | |||
185 | for (int category = 0; category < categoryCount; category++) { |
|
185 | for (int category = 0; category < categoryCount; category++) { | |
186 | for (int set = 0; set < setCount; set++) { |
|
186 | for (int set = 0; set < setCount; set++) { | |
187 |
QBarSetPrivate* |
|
187 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
188 |
Bar* |
|
188 | Bar *bar = m_bars.at(itemIndex); | |
189 | bar->setPen(barSet->m_pen); |
|
189 | bar->setPen(barSet->m_pen); | |
190 | bar->setBrush(barSet->m_brush); |
|
190 | bar->setBrush(barSet->m_brush); | |
191 | bar->update(); |
|
191 | bar->update(); | |
192 |
|
192 | |||
193 |
QGraphicsSimpleTextItem* |
|
193 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
194 | label->setFont(barSet->m_labelFont); |
|
194 | label->setFont(barSet->m_labelFont); | |
195 | label->setBrush(barSet->m_labelBrush); |
|
195 | label->setBrush(barSet->m_labelBrush); | |
196 | label->update(); |
|
196 | label->update(); |
@@ -56,7 +56,7 public: | |||||
56 |
|
56 | |||
57 | virtual QVector<QRectF> calculateLayout() = 0; |
|
57 | virtual QVector<QRectF> calculateLayout() = 0; | |
58 | virtual void applyLayout(const QVector<QRectF> &layout); |
|
58 | virtual void applyLayout(const QVector<QRectF> &layout); | |
59 |
virtual void setAnimation(AbstractBarAnimation* |
|
59 | virtual void setAnimation(AbstractBarAnimation *animation); | |
60 | void setLayout(const QVector<QRectF> &layout); |
|
60 | void setLayout(const QVector<QRectF> &layout); | |
61 | void updateLayout(const QVector<QRectF> &layout); |
|
61 | void updateLayout(const QVector<QRectF> &layout); | |
62 | QRectF geometry() const { return m_rect;} |
|
62 | QRectF geometry() const { return m_rect;} |
@@ -54,14 +54,14 QVector<QRectF> HorizontalBarChartItem::calculateLayout() | |||||
54 | for (int category = 0; category < categoryCount; category++) { |
|
54 | for (int category = 0; category < categoryCount; category++) { | |
55 | qreal xPos = -scaleX * m_domainMinX + geometry().left(); |
|
55 | qreal xPos = -scaleX * m_domainMinX + geometry().left(); | |
56 | for (int set = 0; set < setCount; set++) { |
|
56 | for (int set = 0; set < setCount; set++) { | |
57 |
QBarSetPrivate* |
|
57 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
58 |
|
58 | |||
59 | qreal yPos = geometry().bottom() + (m_domainMinY - barSet->pos(category)) * scaleY; |
|
59 | qreal yPos = geometry().bottom() + (m_domainMinY - barSet->pos(category)) * scaleY; | |
60 | yPos += setCount * rectHeight / 2; |
|
60 | yPos += setCount * rectHeight / 2; | |
61 | yPos -= set * rectHeight; |
|
61 | yPos -= set * rectHeight; | |
62 |
|
62 | |||
63 | qreal rectWidth = barSet->value(category) * scaleX; |
|
63 | qreal rectWidth = barSet->value(category) * scaleX; | |
64 |
Bar* |
|
64 | Bar *bar = m_bars.at(itemIndex); | |
65 |
|
65 | |||
66 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); |
|
66 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); | |
67 | layout.append(rect); |
|
67 | layout.append(rect); | |
@@ -72,7 +72,7 QVector<QRectF> HorizontalBarChartItem::calculateLayout() | |||||
72 | else |
|
72 | else | |
73 | bar->setVisible(barsVisible); |
|
73 | bar->setVisible(barsVisible); | |
74 |
|
74 | |||
75 |
QGraphicsSimpleTextItem* |
|
75 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
76 |
|
76 | |||
77 | if (!qFuzzyIsNull(barSet->value(category))) |
|
77 | if (!qFuzzyIsNull(barSet->value(category))) | |
78 | label->setText(QString::number(barSet->value(category))); |
|
78 | label->setText(QString::number(barSet->value(category))); |
@@ -60,8 +60,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
60 | Constructs empty QHorizontalBarSeries. |
|
60 | Constructs empty QHorizontalBarSeries. | |
61 | QHorizontalBarSeries is QObject which is a child of a \a parent. |
|
61 | QHorizontalBarSeries is QObject which is a child of a \a parent. | |
62 | */ |
|
62 | */ | |
63 |
QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent) |
|
63 | QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent) | |
64 | QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent) |
|
64 | : QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent) | |
65 | { |
|
65 | { | |
66 | } |
|
66 | } | |
67 |
|
67 | |||
@@ -86,12 +86,13 QAbstractSeries::SeriesType QHorizontalBarSeries::type() const | |||||
86 |
|
86 | |||
87 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
87 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
88 |
|
88 | |||
89 |
QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q) |
|
89 | QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q) | |
|
90 | : QAbstractBarSeriesPrivate(q) | |||
90 | { |
|
91 | { | |
91 |
|
92 | |||
92 | } |
|
93 | } | |
93 |
|
94 | |||
94 |
void QHorizontalBarSeriesPrivate::scaleDomain(Domain& |
|
95 | void QHorizontalBarSeriesPrivate::scaleDomain(Domain &domain) | |
95 | { |
|
96 | { | |
96 | qreal minX(domain.minX()); |
|
97 | qreal minX(domain.minX()); | |
97 | qreal minY(domain.minY()); |
|
98 | qreal minY(domain.minY()); | |
@@ -107,11 +108,11 void QHorizontalBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
107 | domain.setRange(minX, maxX, minY, maxY); |
|
108 | domain.setRange(minX, maxX, minY, maxY); | |
108 | } |
|
109 | } | |
109 |
|
110 | |||
110 |
ChartElement* |
|
111 | ChartElement *QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
111 | { |
|
112 | { | |
112 | Q_Q(QHorizontalBarSeries); |
|
113 | Q_Q(QHorizontalBarSeries); | |
113 |
|
114 | |||
114 |
HorizontalBarChartItem* |
|
115 | HorizontalBarChartItem *bar = new HorizontalBarChartItem(q, presenter); | |
115 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
116 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
116 | bar->setAnimation(new HorizontalBarAnimation(bar)); |
|
117 | bar->setAnimation(new HorizontalBarAnimation(bar)); | |
117 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
118 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -38,9 +38,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
38 | class QHorizontalBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
38 | class QHorizontalBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
39 | { |
|
39 | { | |
40 | public: |
|
40 | public: | |
41 |
QHorizontalBarSeriesPrivate(QHorizontalBarSeries* |
|
41 | QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q); | |
42 |
ChartElement* |
|
42 | ChartElement *createGraphics(ChartPresenter *presenter); | |
43 |
void scaleDomain(Domain& |
|
43 | void scaleDomain(Domain &domain); | |
44 | private: |
|
44 | private: | |
45 | Q_DECLARE_PUBLIC(QHorizontalBarSeries) |
|
45 | Q_DECLARE_PUBLIC(QHorizontalBarSeries) | |
46 | }; |
|
46 | }; |
@@ -25,8 +25,8 | |||||
25 |
|
25 | |||
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
27 |
|
27 | |||
28 |
HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) |
|
28 | HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) | |
29 | AbstractBarChartItem(series, presenter) |
|
29 | : AbstractBarChartItem(series, presenter) | |
30 | { |
|
30 | { | |
31 | } |
|
31 | } | |
32 |
|
32 | |||
@@ -54,12 +54,12 QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout() | |||||
54 | qreal percentage = (100 / colSum); |
|
54 | qreal percentage = (100 / colSum); | |
55 | qreal xPos = -scaleX * m_domainMinX + geometry().left(); |
|
55 | qreal xPos = -scaleX * m_domainMinX + geometry().left(); | |
56 | for (int set = 0; set < setCount; set++) { |
|
56 | for (int set = 0; set < setCount; set++) { | |
57 |
QBarSetPrivate* |
|
57 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
58 |
|
58 | |||
59 | qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2; |
|
59 | qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2; | |
60 |
|
60 | |||
61 | qreal rectWidth = barSet->value(category) * percentage * scaleX; |
|
61 | qreal rectWidth = barSet->value(category) * percentage * scaleX; | |
62 |
Bar* |
|
62 | Bar *bar = m_bars.at(itemIndex); | |
63 |
|
63 | |||
64 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); |
|
64 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); | |
65 | layout.append(rect); |
|
65 | layout.append(rect); | |
@@ -70,7 +70,7 QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout() | |||||
70 | else |
|
70 | else | |
71 | bar->setVisible(barsVisible); |
|
71 | bar->setVisible(barsVisible); | |
72 |
|
72 | |||
73 |
QGraphicsSimpleTextItem* |
|
73 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
74 |
|
74 | |||
75 | if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) { |
|
75 | if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) { | |
76 | int p = m_series->d_func()->percentageAt(set, category) * 100; |
|
76 | int p = m_series->d_func()->percentageAt(set, category) * 100; |
@@ -88,7 +88,7 QHorizontalPercentBarSeriesPrivate::QHorizontalPercentBarSeriesPrivate(QHorizont | |||||
88 |
|
88 | |||
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 |
void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain& |
|
91 | void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain &domain) | |
92 | { |
|
92 | { | |
93 | qreal minX(domain.minX()); |
|
93 | qreal minX(domain.minX()); | |
94 | qreal minY(domain.minY()); |
|
94 | qreal minY(domain.minY()); | |
@@ -104,11 +104,11 void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
104 | domain.setRange(minX, maxX, minY, maxY); |
|
104 | domain.setRange(minX, maxX, minY, maxY); | |
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 |
ChartElement* |
|
107 | ChartElement *QHorizontalPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
108 | { |
|
108 | { | |
109 | Q_Q(QHorizontalPercentBarSeries); |
|
109 | Q_Q(QHorizontalPercentBarSeries); | |
110 |
|
110 | |||
111 |
HorizontalPercentBarChartItem* |
|
111 | HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q, presenter); | |
112 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
112 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
113 | bar->setAnimation(new HorizontalPercentBarAnimation(bar)); |
|
113 | bar->setAnimation(new HorizontalPercentBarAnimation(bar)); | |
114 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
114 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -38,9 +38,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
38 | class QHorizontalPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
38 | class QHorizontalPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
39 | { |
|
39 | { | |
40 | public: |
|
40 | public: | |
41 |
QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries* |
|
41 | QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q); | |
42 |
ChartElement* |
|
42 | ChartElement *createGraphics(ChartPresenter *presenter); | |
43 |
void scaleDomain(Domain& |
|
43 | void scaleDomain(Domain &domain); | |
44 | private: |
|
44 | private: | |
45 | Q_DECLARE_PUBLIC(QHorizontalPercentBarSeries) |
|
45 | Q_DECLARE_PUBLIC(QHorizontalPercentBarSeries) | |
46 | }; |
|
46 | }; |
@@ -25,8 +25,8 | |||||
25 |
|
25 | |||
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
27 |
|
27 | |||
28 |
HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) |
|
28 | HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) | |
29 | AbstractBarChartItem(series, presenter) |
|
29 | : AbstractBarChartItem(series, presenter) | |
30 | { |
|
30 | { | |
31 | } |
|
31 | } | |
32 |
|
32 | |||
@@ -53,12 +53,12 QVector<QRectF> HorizontalStackedBarChartItem::calculateLayout() | |||||
53 | qreal xMax = -scaleX * m_domainMinX + geometry().left(); |
|
53 | qreal xMax = -scaleX * m_domainMinX + geometry().left(); | |
54 | qreal xMin = -scaleX * m_domainMinX + geometry().left(); |
|
54 | qreal xMin = -scaleX * m_domainMinX + geometry().left(); | |
55 | for (int set = 0; set < setCount; set++) { |
|
55 | for (int set = 0; set < setCount; set++) { | |
56 |
QBarSetPrivate* |
|
56 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
57 |
|
57 | |||
58 | qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2; |
|
58 | qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2; | |
59 |
|
59 | |||
60 | qreal rectWidth = barSet->value(category) * scaleX; |
|
60 | qreal rectWidth = barSet->value(category) * scaleX; | |
61 |
Bar* |
|
61 | Bar *bar = m_bars.at(itemIndex); | |
62 |
|
62 | |||
63 | bar->setPen(barSet->m_pen); |
|
63 | bar->setPen(barSet->m_pen); | |
64 | bar->setBrush(barSet->m_brush); |
|
64 | bar->setBrush(barSet->m_brush); | |
@@ -67,7 +67,7 QVector<QRectF> HorizontalStackedBarChartItem::calculateLayout() | |||||
67 | else |
|
67 | else | |
68 | bar->setVisible(barsVisible); |
|
68 | bar->setVisible(barsVisible); | |
69 |
|
69 | |||
70 |
QGraphicsSimpleTextItem* |
|
70 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
71 |
|
71 | |||
72 | if (!qFuzzyIsNull(barSet->value(category))) |
|
72 | if (!qFuzzyIsNull(barSet->value(category))) | |
73 | label->setText(QString::number(barSet->value(category))); |
|
73 | label->setText(QString::number(barSet->value(category))); |
@@ -56,8 +56,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
56 | Constructs empty QHorizontalStackedBarSeries. |
|
56 | Constructs empty QHorizontalStackedBarSeries. | |
57 | QHorizontalStackedBarSeries is QObject which is a child of a \a parent. |
|
57 | QHorizontalStackedBarSeries is QObject which is a child of a \a parent. | |
58 | */ |
|
58 | */ | |
59 |
QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent) |
|
59 | QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent) | |
60 | QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent) |
|
60 | : QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent) | |
61 | { |
|
61 | { | |
62 | } |
|
62 | } | |
63 |
|
63 | |||
@@ -87,7 +87,7 QHorizontalStackedBarSeriesPrivate::QHorizontalStackedBarSeriesPrivate(QHorizont | |||||
87 |
|
87 | |||
88 | } |
|
88 | } | |
89 |
|
89 | |||
90 |
void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain& |
|
90 | void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain &domain) | |
91 | { |
|
91 | { | |
92 | qreal minX(domain.minX()); |
|
92 | qreal minX(domain.minX()); | |
93 | qreal minY(domain.minY()); |
|
93 | qreal minY(domain.minY()); | |
@@ -103,11 +103,11 void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
103 | domain.setRange(minX, maxX, minY, maxY); |
|
103 | domain.setRange(minX, maxX, minY, maxY); | |
104 | } |
|
104 | } | |
105 |
|
105 | |||
106 |
ChartElement* |
|
106 | ChartElement *QHorizontalStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
107 | { |
|
107 | { | |
108 | Q_Q(QHorizontalStackedBarSeries); |
|
108 | Q_Q(QHorizontalStackedBarSeries); | |
109 |
|
109 | |||
110 |
HorizontalStackedBarChartItem* |
|
110 | HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q, presenter); | |
111 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
111 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
112 | bar->setAnimation(new HorizontalStackedBarAnimation(bar)); |
|
112 | bar->setAnimation(new HorizontalStackedBarAnimation(bar)); | |
113 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
113 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -38,9 +38,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
38 | class QHorizontalStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
38 | class QHorizontalStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
39 | { |
|
39 | { | |
40 | public: |
|
40 | public: | |
41 |
QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries* |
|
41 | QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q); | |
42 |
ChartElement* |
|
42 | ChartElement *createGraphics(ChartPresenter *presenter); | |
43 |
void scaleDomain(Domain& |
|
43 | void scaleDomain(Domain &domain); | |
44 | private: |
|
44 | private: | |
45 | Q_DECLARE_PUBLIC(QHorizontalStackedBarSeries) |
|
45 | Q_DECLARE_PUBLIC(QHorizontalStackedBarSeries) | |
46 | }; |
|
46 | }; |
@@ -236,7 +236,7 bool QAbstractBarSeries::append(QBarSet *set) | |||||
236 | Q_D(QAbstractBarSeries); |
|
236 | Q_D(QAbstractBarSeries); | |
237 | bool success = d->append(set); |
|
237 | bool success = d->append(set); | |
238 | if (success) { |
|
238 | if (success) { | |
239 | QList<QBarSet*> sets; |
|
239 | QList<QBarSet *> sets; | |
240 | sets.append(set); |
|
240 | sets.append(set); | |
241 | set->setParent(this); |
|
241 | set->setParent(this); | |
242 | emit barsetsAdded(sets); |
|
242 | emit barsetsAdded(sets); | |
@@ -255,7 +255,7 bool QAbstractBarSeries::remove(QBarSet *set) | |||||
255 | Q_D(QAbstractBarSeries); |
|
255 | Q_D(QAbstractBarSeries); | |
256 | bool success = d->remove(set); |
|
256 | bool success = d->remove(set); | |
257 | if (success) { |
|
257 | if (success) { | |
258 | QList<QBarSet*> sets; |
|
258 | QList<QBarSet *> sets; | |
259 | sets.append(set); |
|
259 | sets.append(set); | |
260 | set->setParent(0); |
|
260 | set->setParent(0); | |
261 | emit barsetsRemoved(sets); |
|
261 | emit barsetsRemoved(sets); | |
@@ -279,7 +279,7 bool QAbstractBarSeries::take(QBarSet *set) | |||||
279 | Q_D(QAbstractBarSeries); |
|
279 | Q_D(QAbstractBarSeries); | |
280 | bool success = d->remove(set); |
|
280 | bool success = d->remove(set); | |
281 | if (success) { |
|
281 | if (success) { | |
282 | QList<QBarSet*> sets; |
|
282 | QList<QBarSet *> sets; | |
283 | sets.append(set); |
|
283 | sets.append(set); | |
284 | emit barsetsRemoved(sets); |
|
284 | emit barsetsRemoved(sets); | |
285 | emit countChanged(); |
|
285 | emit countChanged(); | |
@@ -293,7 +293,7 bool QAbstractBarSeries::take(QBarSet *set) | |||||
293 | nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended |
|
293 | nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended | |
294 | and function returns false. |
|
294 | and function returns false. | |
295 | */ |
|
295 | */ | |
296 |
bool QAbstractBarSeries::append(QList<QBarSet* |
|
296 | bool QAbstractBarSeries::append(QList<QBarSet *> sets) | |
297 | { |
|
297 | { | |
298 | Q_D(QAbstractBarSeries); |
|
298 | Q_D(QAbstractBarSeries); | |
299 | bool success = d->append(sets); |
|
299 | bool success = d->append(sets); | |
@@ -314,7 +314,7 bool QAbstractBarSeries::insert(int index, QBarSet *set) | |||||
314 | Q_D(QAbstractBarSeries); |
|
314 | Q_D(QAbstractBarSeries); | |
315 | bool success = d->insert(index, set); |
|
315 | bool success = d->insert(index, set); | |
316 | if (success) { |
|
316 | if (success) { | |
317 | QList<QBarSet*> sets; |
|
317 | QList<QBarSet *> sets; | |
318 | sets.append(set); |
|
318 | sets.append(set); | |
319 | emit barsetsAdded(sets); |
|
319 | emit barsetsAdded(sets); | |
320 | emit countChanged(); |
|
320 | emit countChanged(); | |
@@ -350,7 +350,7 int QAbstractBarSeries::count() const | |||||
350 | /*! |
|
350 | /*! | |
351 | Returns a list of sets in series. Keeps ownership of sets. |
|
351 | Returns a list of sets in series. Keeps ownership of sets. | |
352 | */ |
|
352 | */ | |
353 | QList<QBarSet*> QAbstractBarSeries::barSets() const |
|
353 | QList<QBarSet *> QAbstractBarSeries::barSets() const | |
354 | { |
|
354 | { | |
355 | Q_D(const QAbstractBarSeries); |
|
355 | Q_D(const QAbstractBarSeries); | |
356 | return d->m_barSets; |
|
356 | return d->m_barSets; | |
@@ -412,7 +412,7 qreal QAbstractBarSeriesPrivate::barWidth() const | |||||
412 | return m_barWidth; |
|
412 | return m_barWidth; | |
413 | } |
|
413 | } | |
414 |
|
414 | |||
415 |
QBarSet* |
|
415 | QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index) | |
416 | { |
|
416 | { | |
417 | return m_barSets.at(index); |
|
417 | return m_barSets.at(index); | |
418 | } |
|
418 | } | |
@@ -623,7 +623,7 qreal QAbstractBarSeriesPrivate::bottom() | |||||
623 | } |
|
623 | } | |
624 |
|
624 | |||
625 |
|
625 | |||
626 |
void QAbstractBarSeriesPrivate::scaleDomain(Domain& |
|
626 | void QAbstractBarSeriesPrivate::scaleDomain(Domain &domain) | |
627 | { |
|
627 | { | |
628 | qreal minX(domain.minX()); |
|
628 | qreal minX(domain.minX()); | |
629 | qreal minY(domain.minY()); |
|
629 | qreal minY(domain.minY()); | |
@@ -641,17 +641,17 void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
641 | domain.setRange(minX, maxX, minY, maxY); |
|
641 | domain.setRange(minX, maxX, minY, maxY); | |
642 | } |
|
642 | } | |
643 |
|
643 | |||
644 |
ChartElement* |
|
644 | ChartElement *QAbstractBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
645 | { |
|
645 | { | |
646 | Q_UNUSED(presenter); |
|
646 | Q_UNUSED(presenter); | |
647 | qWarning() << "QAbstractBarSeriesPrivate::createGraphics called"; |
|
647 | qWarning() << "QAbstractBarSeriesPrivate::createGraphics called"; | |
648 | return 0; |
|
648 | return 0; | |
649 | } |
|
649 | } | |
650 |
|
650 | |||
651 |
QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* |
|
651 | QList<LegendMarker *> QAbstractBarSeriesPrivate::createLegendMarker(QLegend *legend) | |
652 | { |
|
652 | { | |
653 | Q_Q(QAbstractBarSeries); |
|
653 | Q_Q(QAbstractBarSeries); | |
654 | QList<LegendMarker*> markers; |
|
654 | QList<LegendMarker *> markers; | |
655 | foreach (QBarSet *set, q->barSets()) { |
|
655 | foreach (QBarSet *set, q->barSets()) { | |
656 | BarLegendMarker* marker = new BarLegendMarker(q, set, legend); |
|
656 | BarLegendMarker* marker = new BarLegendMarker(q, set, legend); | |
657 | markers << marker; |
|
657 | markers << marker; | |
@@ -688,7 +688,7 bool QAbstractBarSeriesPrivate::remove(QBarSet *set) | |||||
688 | return true; |
|
688 | return true; | |
689 | } |
|
689 | } | |
690 |
|
690 | |||
691 | bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets) |
|
691 | bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets) | |
692 | { |
|
692 | { | |
693 | foreach (QBarSet *set, sets) { |
|
693 | foreach (QBarSet *set, sets) { | |
694 | if ((set == 0) || (m_barSets.contains(set))) |
|
694 | if ((set == 0) || (m_barSets.contains(set))) | |
@@ -708,7 +708,7 bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets) | |||||
708 | return true; |
|
708 | return true; | |
709 | } |
|
709 | } | |
710 |
|
710 | |||
711 | bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets) |
|
711 | bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets) | |
712 | { |
|
712 | { | |
713 | if (sets.count() == 0) |
|
713 | if (sets.count() == 0) | |
714 | return false; |
|
714 | return false; | |
@@ -745,7 +745,7 bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set) | |||||
745 | return true; |
|
745 | return true; | |
746 | } |
|
746 | } | |
747 |
|
747 | |||
748 |
void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* |
|
748 | void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis *axis) | |
749 | { |
|
749 | { | |
750 | Q_Q(QAbstractBarSeries); |
|
750 | Q_Q(QAbstractBarSeries); | |
751 |
|
751 | |||
@@ -755,13 +755,13 void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |||||
755 | case QAbstractSeries::SeriesTypeHorizontalPercentBar: |
|
755 | case QAbstractSeries::SeriesTypeHorizontalPercentBar: | |
756 | case QAbstractSeries::SeriesTypeHorizontalStackedBar: |
|
756 | case QAbstractSeries::SeriesTypeHorizontalStackedBar: | |
757 | if (axis->orientation() == Qt::Vertical) |
|
757 | if (axis->orientation() == Qt::Vertical) | |
758 | populateCategories(qobject_cast<QBarCategoryAxis*>(axis)); |
|
758 | populateCategories(qobject_cast<QBarCategoryAxis *>(axis)); | |
759 | break; |
|
759 | break; | |
760 | case QAbstractSeries::SeriesTypeBar: |
|
760 | case QAbstractSeries::SeriesTypeBar: | |
761 | case QAbstractSeries::SeriesTypePercentBar: |
|
761 | case QAbstractSeries::SeriesTypePercentBar: | |
762 | case QAbstractSeries::SeriesTypeStackedBar: |
|
762 | case QAbstractSeries::SeriesTypeStackedBar: | |
763 | if (axis->orientation() == Qt::Horizontal) |
|
763 | if (axis->orientation() == Qt::Horizontal) | |
764 | populateCategories(qobject_cast<QBarCategoryAxis*>(axis)); |
|
764 | populateCategories(qobject_cast<QBarCategoryAxis *>(axis)); | |
765 | break; |
|
765 | break; | |
766 | default: |
|
766 | default: | |
767 | qWarning() << "Unexpected series type"; |
|
767 | qWarning() << "Unexpected series type"; | |
@@ -795,7 +795,7 QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientati | |||||
795 |
|
795 | |||
796 | } |
|
796 | } | |
797 |
|
797 | |||
798 |
void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis* |
|
798 | void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis) | |
799 | { |
|
799 | { | |
800 | QStringList categories; |
|
800 | QStringList categories; | |
801 | if (axis->categories().isEmpty()) { |
|
801 | if (axis->categories().isEmpty()) { |
@@ -46,10 +46,10 public: | |||||
46 | bool append(QBarSet *set); |
|
46 | bool append(QBarSet *set); | |
47 | bool remove(QBarSet *set); |
|
47 | bool remove(QBarSet *set); | |
48 | bool take(QBarSet *set); |
|
48 | bool take(QBarSet *set); | |
49 |
bool append(QList<QBarSet* |
|
49 | bool append(QList<QBarSet *> sets); | |
50 | bool insert(int index, QBarSet *set); |
|
50 | bool insert(int index, QBarSet *set); | |
51 | int count() const; |
|
51 | int count() const; | |
52 | QList<QBarSet*> barSets() const; |
|
52 | QList<QBarSet *> barSets() const; | |
53 | void clear(); |
|
53 | void clear(); | |
54 |
|
54 | |||
55 | void setLabelsVisible(bool visible = true); |
|
55 | void setLabelsVisible(bool visible = true); | |
@@ -64,8 +64,8 Q_SIGNALS: | |||||
64 | void countChanged(); |
|
64 | void countChanged(); | |
65 | void labelsVisibleChanged(); |
|
65 | void labelsVisibleChanged(); | |
66 |
|
66 | |||
67 | void barsetsAdded(QList<QBarSet*> sets); |
|
67 | void barsetsAdded(QList<QBarSet *> sets); | |
68 | void barsetsRemoved(QList<QBarSet*> sets); |
|
68 | void barsetsRemoved(QList<QBarSet *> sets); | |
69 |
|
69 | |||
70 | protected: |
|
70 | protected: | |
71 | Q_DECLARE_PRIVATE(QAbstractBarSeries) |
|
71 | Q_DECLARE_PRIVATE(QAbstractBarSeries) |
@@ -53,20 +53,20 public: | |||||
53 | void setVisible(bool visible); |
|
53 | void setVisible(bool visible); | |
54 | void setLabelsVisible(bool visible); |
|
54 | void setLabelsVisible(bool visible); | |
55 |
|
55 | |||
56 |
void scaleDomain(Domain& |
|
56 | void scaleDomain(Domain &domain); | |
57 |
ChartElement* |
|
57 | ChartElement *createGraphics(ChartPresenter *presenter); | |
58 |
QList<LegendMarker*> createLegendMarker(QLegend* |
|
58 | QList<LegendMarker *> createLegendMarker(QLegend *legend); | |
59 |
|
59 | |||
60 |
void initializeAxis(QAbstractAxis* |
|
60 | void initializeAxis(QAbstractAxis *axis); | |
61 | virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; |
|
61 | virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
62 |
|
62 | |||
63 | bool append(QBarSet *set); |
|
63 | bool append(QBarSet *set); | |
64 | bool remove(QBarSet *set); |
|
64 | bool remove(QBarSet *set); | |
65 |
bool append(QList<QBarSet* |
|
65 | bool append(QList<QBarSet *> sets); | |
66 |
bool remove(QList<QBarSet* |
|
66 | bool remove(QList<QBarSet *> sets); | |
67 | bool insert(int index, QBarSet *set); |
|
67 | bool insert(int index, QBarSet *set); | |
68 |
|
68 | |||
69 |
QBarSet* |
|
69 | QBarSet *barsetAt(int index); | |
70 | qreal min(); |
|
70 | qreal min(); | |
71 | qreal max(); |
|
71 | qreal max(); | |
72 | qreal valueAt(int set, int category); |
|
72 | qreal valueAt(int set, int category); | |
@@ -90,7 +90,7 Q_SIGNALS: | |||||
90 | void visibleChanged(); |
|
90 | void visibleChanged(); | |
91 |
|
91 | |||
92 | private: |
|
92 | private: | |
93 |
void populateCategories(QBarCategoryAxis* |
|
93 | void populateCategories(QBarCategoryAxis *axis); | |
94 |
|
94 | |||
95 | protected: |
|
95 | protected: | |
96 | QList<QBarSet *> m_barSets; |
|
96 | QList<QBarSet *> m_barSets; |
@@ -33,7 +33,7 QBarModelMapper::QBarModelMapper(QObject *parent) : | |||||
33 | { |
|
33 | { | |
34 | } |
|
34 | } | |
35 |
|
35 | |||
36 |
QAbstractItemModel* |
|
36 | QAbstractItemModel *QBarModelMapper::model() const | |
37 | { |
|
37 | { | |
38 | Q_D(const QBarModelMapper); |
|
38 | Q_D(const QBarModelMapper); | |
39 | return d->m_model; |
|
39 | return d->m_model; | |
@@ -60,7 +60,7 void QBarModelMapper::setModel(QAbstractItemModel *model) | |||||
60 | connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed())); |
|
60 | connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed())); | |
61 | } |
|
61 | } | |
62 |
|
62 | |||
63 |
QAbstractBarSeries* |
|
63 | QAbstractBarSeries *QBarModelMapper::series() const | |
64 | { |
|
64 | { | |
65 | Q_D(const QBarModelMapper); |
|
65 | Q_D(const QBarModelMapper); | |
66 | return d->m_series; |
|
66 | return d->m_series; | |
@@ -215,7 +215,7 void QBarModelMapperPrivate::blockSeriesSignals(bool block) | |||||
215 | m_seriesSignalsBlock = block; |
|
215 | m_seriesSignalsBlock = block; | |
216 | } |
|
216 | } | |
217 |
|
217 | |||
218 |
QBarSet* |
|
218 | QBarSet *QBarModelMapperPrivate::barSet(QModelIndex index) | |
219 | { |
|
219 | { | |
220 | if (!index.isValid()) |
|
220 | if (!index.isValid()) | |
221 | return 0; |
|
221 | return 0; | |
@@ -269,7 +269,7 void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex botto | |||||
269 | for (int row = topLeft.row(); row <= bottomRight.row(); row++) { |
|
269 | for (int row = topLeft.row(); row <= bottomRight.row(); row++) { | |
270 | for (int column = topLeft.column(); column <= bottomRight.column(); column++) { |
|
270 | for (int column = topLeft.column(); column <= bottomRight.column(); column++) { | |
271 | index = topLeft.sibling(row, column); |
|
271 | index = topLeft.sibling(row, column); | |
272 |
QBarSet* |
|
272 | QBarSet *bar = barSet(index); | |
273 | if (bar) { |
|
273 | if (bar) { | |
274 | if (m_orientation == Qt::Vertical) |
|
274 | if (m_orientation == Qt::Vertical) | |
275 | bar->replace(row - m_first, m_model->data(index).toReal()); |
|
275 | bar->replace(row - m_first, m_model->data(index).toReal()); | |
@@ -293,7 +293,7 void QBarModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, | |||||
293 | if (orientation != m_orientation) { |
|
293 | if (orientation != m_orientation) { | |
294 | for (int section = first; section <= last; section++) { |
|
294 | for (int section = first; section <= last; section++) { | |
295 | if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) { |
|
295 | if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) { | |
296 |
QBarSet* |
|
296 | QBarSet *bar = m_series->barSets().at(section - m_firstBarSetSection); | |
297 | if (bar) |
|
297 | if (bar) | |
298 | bar->setLabel(m_model->headerData(section, orientation).toString()); |
|
298 | bar->setLabel(m_model->headerData(section, orientation).toString()); | |
299 | } |
|
299 | } | |
@@ -387,7 +387,7 void QBarModelMapperPrivate::removeData(int start, int end) | |||||
387 | // To be implemented |
|
387 | // To be implemented | |
388 | } |
|
388 | } | |
389 |
|
389 | |||
390 | void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets) |
|
390 | void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet *> sets) | |
391 | { |
|
391 | { | |
392 | if (m_seriesSignalsBlock) |
|
392 | if (m_seriesSignalsBlock) | |
393 | return; |
|
393 | return; | |
@@ -434,7 +434,7 void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets) | |||||
434 | initializeBarFromModel(); |
|
434 | initializeBarFromModel(); | |
435 | } |
|
435 | } | |
436 |
|
436 | |||
437 | void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet*> sets) |
|
437 | void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet *> sets) | |
438 | { |
|
438 | { | |
439 | if (m_seriesSignalsBlock) |
|
439 | if (m_seriesSignalsBlock) | |
440 | return; |
|
440 | return; |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QBarModelMapper : public QObject | |||||
38 | protected: |
|
38 | protected: | |
39 | explicit QBarModelMapper(QObject *parent = 0); |
|
39 | explicit QBarModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QAbstractBarSeries* |
|
44 | QAbstractBarSeries *series() const; | |
45 | void setSeries(QAbstractBarSeries *series); |
|
45 | void setSeries(QAbstractBarSeries *series); | |
46 |
|
46 | |||
47 | int first() const; |
|
47 | int first() const; |
@@ -56,8 +56,8 public Q_SLOTS: | |||||
56 | void handleModelDestroyed(); |
|
56 | void handleModelDestroyed(); | |
57 |
|
57 | |||
58 | // for the series |
|
58 | // for the series | |
59 | void barSetsAdded(QList<QBarSet*> sets); |
|
59 | void barSetsAdded(QList<QBarSet *> sets); | |
60 | void barSetsRemoved(QList<QBarSet*> sets); |
|
60 | void barSetsRemoved(QList<QBarSet *> sets); | |
61 | void valuesAdded(int index, int count); |
|
61 | void valuesAdded(int index, int count); | |
62 | void valuesRemoved(int index, int count); |
|
62 | void valuesRemoved(int index, int count); | |
63 | void barLabelChanged(); |
|
63 | void barLabelChanged(); | |
@@ -67,7 +67,7 public Q_SLOTS: | |||||
67 | void initializeBarFromModel(); |
|
67 | void initializeBarFromModel(); | |
68 |
|
68 | |||
69 | private: |
|
69 | private: | |
70 |
QBarSet* |
|
70 | QBarSet *barSet(QModelIndex index); | |
71 | QModelIndex barModelIndex(int barSection, int posInBar); |
|
71 | QModelIndex barModelIndex(int barSection, int posInBar); | |
72 | void insertData(int start, int end); |
|
72 | void insertData(int start, int end); | |
73 | void removeData(int start, int end); |
|
73 | void removeData(int start, int end); | |
@@ -76,7 +76,7 private: | |||||
76 |
|
76 | |||
77 | private: |
|
77 | private: | |
78 | QAbstractBarSeries *m_series; |
|
78 | QAbstractBarSeries *m_series; | |
79 | QList<QBarSet*> m_barSets; |
|
79 | QList<QBarSet *> m_barSets; | |
80 | QAbstractItemModel *m_model; |
|
80 | QAbstractItemModel *m_model; | |
81 | int m_first; |
|
81 | int m_first; | |
82 | int m_count; |
|
82 | int m_count; |
@@ -307,7 +307,7 void QBarSet::append(const QList<qreal> &values) | |||||
307 | Convenience operator. Same as append, with real \a value. |
|
307 | Convenience operator. Same as append, with real \a value. | |
308 | \sa append() |
|
308 | \sa append() | |
309 | */ |
|
309 | */ | |
310 |
QBarSet& |
|
310 | QBarSet &QBarSet::operator << (const qreal &value) | |
311 | { |
|
311 | { | |
312 | append(value); |
|
312 | append(value); | |
313 | return *this; |
|
313 | return *this; |
@@ -51,7 +51,7 public: | |||||
51 | void append(const qreal value); |
|
51 | void append(const qreal value); | |
52 | void append(const QList<qreal> &values); |
|
52 | void append(const QList<qreal> &values); | |
53 |
|
53 | |||
54 |
QBarSet& |
|
54 | QBarSet &operator << (const qreal &value); | |
55 |
|
55 | |||
56 | void insert(const int index, const qreal value); |
|
56 | void insert(const int index, const qreal value); | |
57 | void remove(const int index, const int count = 1); |
|
57 | void remove(const int index, const int count = 1); |
@@ -166,7 +166,7 QHBarModelMapper::QHBarModelMapper(QObject *parent) : | |||||
166 | QBarModelMapper::setOrientation(Qt::Horizontal); |
|
166 | QBarModelMapper::setOrientation(Qt::Horizontal); | |
167 | } |
|
167 | } | |
168 |
|
168 | |||
169 |
QAbstractItemModel* |
|
169 | QAbstractItemModel *QHBarModelMapper::model() const | |
170 | { |
|
170 | { | |
171 | return QBarModelMapper::model(); |
|
171 | return QBarModelMapper::model(); | |
172 | } |
|
172 | } | |
@@ -179,7 +179,7 void QHBarModelMapper::setModel(QAbstractItemModel *model) | |||||
179 | } |
|
179 | } | |
180 | } |
|
180 | } | |
181 |
|
181 | |||
182 |
QAbstractBarSeries* |
|
182 | QAbstractBarSeries *QHBarModelMapper::series() const | |
183 | { |
|
183 | { | |
184 | return QBarModelMapper::series(); |
|
184 | return QBarModelMapper::series(); | |
185 | } |
|
185 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QHBarModelMapper : public QBarModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QHBarModelMapper(QObject *parent = 0); |
|
39 | explicit QHBarModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QAbstractBarSeries* |
|
44 | QAbstractBarSeries *series() const; | |
45 | void setSeries(QAbstractBarSeries *series); |
|
45 | void setSeries(QAbstractBarSeries *series); | |
46 |
|
46 | |||
47 | int firstBarSetRow() const; |
|
47 | int firstBarSetRow() const; |
@@ -165,7 +165,7 QVBarModelMapper::QVBarModelMapper(QObject *parent) : | |||||
165 | QBarModelMapper::setOrientation(Qt::Vertical); |
|
165 | QBarModelMapper::setOrientation(Qt::Vertical); | |
166 | } |
|
166 | } | |
167 |
|
167 | |||
168 |
QAbstractItemModel* |
|
168 | QAbstractItemModel *QVBarModelMapper::model() const | |
169 | { |
|
169 | { | |
170 | return QBarModelMapper::model(); |
|
170 | return QBarModelMapper::model(); | |
171 | } |
|
171 | } | |
@@ -178,7 +178,7 void QVBarModelMapper::setModel(QAbstractItemModel *model) | |||||
178 | } |
|
178 | } | |
179 | } |
|
179 | } | |
180 |
|
180 | |||
181 |
QAbstractBarSeries* |
|
181 | QAbstractBarSeries *QVBarModelMapper::series() const | |
182 | { |
|
182 | { | |
183 | return QBarModelMapper::series(); |
|
183 | return QBarModelMapper::series(); | |
184 | } |
|
184 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QVBarModelMapper : public QBarModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QVBarModelMapper(QObject *parent = 0); |
|
39 | explicit QVBarModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QAbstractBarSeries* |
|
44 | QAbstractBarSeries *series() const; | |
45 | void setSeries(QAbstractBarSeries *series); |
|
45 | void setSeries(QAbstractBarSeries *series); | |
46 |
|
46 | |||
47 | int firstBarSetColumn() const; |
|
47 | int firstBarSetColumn() const; |
@@ -53,14 +53,14 QVector<QRectF> BarChartItem::calculateLayout() | |||||
53 | for (int category = 0; category < categoryCount; category++) { |
|
53 | for (int category = 0; category < categoryCount; category++) { | |
54 | qreal yPos = height + scaleY * m_domainMinY + geometry().top(); |
|
54 | qreal yPos = height + scaleY * m_domainMinY + geometry().top(); | |
55 | for (int set = 0; set < setCount; set++) { |
|
55 | for (int set = 0; set < setCount; set++) { | |
56 |
QBarSetPrivate* |
|
56 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
57 |
|
57 | |||
58 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left(); |
|
58 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left(); | |
59 | xPos -= setCount * rectWidth / 2; |
|
59 | xPos -= setCount * rectWidth / 2; | |
60 | xPos += set * rectWidth; |
|
60 | xPos += set * rectWidth; | |
61 |
|
61 | |||
62 | qreal rectHeight = barSet->value(category) * scaleY; |
|
62 | qreal rectHeight = barSet->value(category) * scaleY; | |
63 |
Bar* |
|
63 | Bar *bar = m_bars.at(itemIndex); | |
64 |
|
64 | |||
65 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); |
|
65 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); | |
66 | layout.append(rect); |
|
66 | layout.append(rect); | |
@@ -71,7 +71,7 QVector<QRectF> BarChartItem::calculateLayout() | |||||
71 | else |
|
71 | else | |
72 | bar->setVisible(barsVisible); |
|
72 | bar->setVisible(barsVisible); | |
73 |
|
73 | |||
74 |
QGraphicsSimpleTextItem* |
|
74 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
75 |
|
75 | |||
76 | if (!qFuzzyIsNull(barSet->value(category))) |
|
76 | if (!qFuzzyIsNull(barSet->value(category))) | |
77 | label->setText(QString::number(barSet->value(category))); |
|
77 | label->setText(QString::number(barSet->value(category))); |
@@ -89,7 +89,7 QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate( | |||||
89 |
|
89 | |||
90 | } |
|
90 | } | |
91 |
|
91 | |||
92 |
void QBarSeriesPrivate::scaleDomain(Domain& |
|
92 | void QBarSeriesPrivate::scaleDomain(Domain &domain) | |
93 | { |
|
93 | { | |
94 | qreal minX(domain.minX()); |
|
94 | qreal minX(domain.minX()); | |
95 | qreal minY(domain.minY()); |
|
95 | qreal minY(domain.minY()); | |
@@ -106,11 +106,11 void QBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
106 | } |
|
106 | } | |
107 |
|
107 | |||
108 |
|
108 | |||
109 |
ChartElement* |
|
109 | ChartElement *QBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
110 | { |
|
110 | { | |
111 | Q_Q(QBarSeries); |
|
111 | Q_Q(QBarSeries); | |
112 |
|
112 | |||
113 |
BarChartItem* |
|
113 | BarChartItem *bar = new BarChartItem(q, presenter); | |
114 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
114 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
115 | bar->setAnimation(new BarAnimation(bar)); |
|
115 | bar->setAnimation(new BarAnimation(bar)); | |
116 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
116 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -39,9 +39,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
39 | class QBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
39 | class QBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
40 | { |
|
40 | { | |
41 | public: |
|
41 | public: | |
42 |
QBarSeriesPrivate(QBarSeries* |
|
42 | QBarSeriesPrivate(QBarSeries *q); | |
43 |
ChartElement* |
|
43 | ChartElement *createGraphics(ChartPresenter *presenter); | |
44 |
void scaleDomain(Domain& |
|
44 | void scaleDomain(Domain &domain); | |
45 | private: |
|
45 | private: | |
46 | Q_DECLARE_PUBLIC(QBarSeries) |
|
46 | Q_DECLARE_PUBLIC(QBarSeries) | |
47 | }; |
|
47 | }; |
@@ -55,12 +55,12 QVector<QRectF> PercentBarChartItem::calculateLayout() | |||||
55 | qreal percentage = (100 / colSum); |
|
55 | qreal percentage = (100 / colSum); | |
56 | qreal yPos = height + scaleY * m_domainMinY + geometry().top(); |
|
56 | qreal yPos = height + scaleY * m_domainMinY + geometry().top(); | |
57 | for (int set = 0; set < setCount; set++) { |
|
57 | for (int set = 0; set < setCount; set++) { | |
58 |
QBarSetPrivate* |
|
58 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
59 |
|
59 | |||
60 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2; |
|
60 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2; | |
61 |
|
61 | |||
62 | qreal rectHeight = barSet->value(category) * percentage * scaleY; |
|
62 | qreal rectHeight = barSet->value(category) * percentage * scaleY; | |
63 |
Bar* |
|
63 | Bar *bar = m_bars.at(itemIndex); | |
64 | bar->setPen(barSet->m_pen); |
|
64 | bar->setPen(barSet->m_pen); | |
65 | bar->setBrush(barSet->m_brush); |
|
65 | bar->setBrush(barSet->m_brush); | |
66 | if (qFuzzyIsNull(rectHeight)) |
|
66 | if (qFuzzyIsNull(rectHeight)) | |
@@ -71,7 +71,7 QVector<QRectF> PercentBarChartItem::calculateLayout() | |||||
71 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); |
|
71 | QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); | |
72 | layout.append(rect); |
|
72 | layout.append(rect); | |
73 |
|
73 | |||
74 |
QGraphicsSimpleTextItem* |
|
74 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
75 |
|
75 | |||
76 | if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) { |
|
76 | if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) { | |
77 | int p = m_series->d_func()->percentageAt(set, category) * 100; |
|
77 | int p = m_series->d_func()->percentageAt(set, category) * 100; |
@@ -88,7 +88,7 QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbst | |||||
88 |
|
88 | |||
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 |
void QPercentBarSeriesPrivate::scaleDomain(Domain& |
|
91 | void QPercentBarSeriesPrivate::scaleDomain(Domain &domain) | |
92 | { |
|
92 | { | |
93 | qreal minX(domain.minX()); |
|
93 | qreal minX(domain.minX()); | |
94 | qreal minY(domain.minY()); |
|
94 | qreal minY(domain.minY()); | |
@@ -105,11 +105,11 void QPercentBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 |
|
107 | |||
108 |
ChartElement* |
|
108 | ChartElement *QPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
109 | { |
|
109 | { | |
110 | Q_Q(QPercentBarSeries); |
|
110 | Q_Q(QPercentBarSeries); | |
111 |
|
111 | |||
112 |
PercentBarChartItem* |
|
112 | PercentBarChartItem *bar = new PercentBarChartItem(q, presenter); | |
113 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
113 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
114 | bar->setAnimation(new PercentBarAnimation(bar)); |
|
114 | bar->setAnimation(new PercentBarAnimation(bar)); | |
115 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
115 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -39,9 +39,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
39 | class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
39 | class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
40 | { |
|
40 | { | |
41 | public: |
|
41 | public: | |
42 |
QPercentBarSeriesPrivate(QPercentBarSeries* |
|
42 | QPercentBarSeriesPrivate(QPercentBarSeries *q); | |
43 |
void scaleDomain(Domain& |
|
43 | void scaleDomain(Domain &domain); | |
44 |
ChartElement* |
|
44 | ChartElement *createGraphics(ChartPresenter *presenter); | |
45 | private: |
|
45 | private: | |
46 | Q_DECLARE_PUBLIC(QPercentBarSeries) |
|
46 | Q_DECLARE_PUBLIC(QPercentBarSeries) | |
47 | }; |
|
47 | }; |
@@ -88,7 +88,7 QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbst | |||||
88 |
|
88 | |||
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 |
void QStackedBarSeriesPrivate::scaleDomain(Domain& |
|
91 | void QStackedBarSeriesPrivate::scaleDomain(Domain &domain) | |
92 | { |
|
92 | { | |
93 | qreal minX(domain.minX()); |
|
93 | qreal minX(domain.minX()); | |
94 | qreal minY(domain.minY()); |
|
94 | qreal minY(domain.minY()); | |
@@ -104,11 +104,11 void QStackedBarSeriesPrivate::scaleDomain(Domain& domain) | |||||
104 | domain.setRange(minX, maxX, minY, maxY); |
|
104 | domain.setRange(minX, maxX, minY, maxY); | |
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 |
ChartElement* |
|
107 | ChartElement *QStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
108 | { |
|
108 | { | |
109 | Q_Q(QStackedBarSeries); |
|
109 | Q_Q(QStackedBarSeries); | |
110 |
|
110 | |||
111 |
StackedBarChartItem* |
|
111 | StackedBarChartItem *bar = new StackedBarChartItem(q, presenter); | |
112 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
112 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
113 | bar->setAnimation(new StackedBarAnimation(bar)); |
|
113 | bar->setAnimation(new StackedBarAnimation(bar)); | |
114 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
114 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -39,9 +39,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
39 | class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate |
|
39 | class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate | |
40 | { |
|
40 | { | |
41 | public: |
|
41 | public: | |
42 |
QStackedBarSeriesPrivate(QStackedBarSeries* |
|
42 | QStackedBarSeriesPrivate(QStackedBarSeries *q); | |
43 |
ChartElement* |
|
43 | ChartElement *createGraphics(ChartPresenter *presenter); | |
44 |
void scaleDomain(Domain& |
|
44 | void scaleDomain(Domain &domain); | |
45 | private: |
|
45 | private: | |
46 | Q_DECLARE_PUBLIC(QStackedBarSeries) |
|
46 | Q_DECLARE_PUBLIC(QStackedBarSeries) | |
47 | }; |
|
47 | }; |
@@ -53,12 +53,12 QVector<QRectF> StackedBarChartItem::calculateLayout() | |||||
53 | qreal yMax = height + scaleY * m_domainMinY + geometry().top(); |
|
53 | qreal yMax = height + scaleY * m_domainMinY + geometry().top(); | |
54 | qreal yMin = height + scaleY * m_domainMinY + geometry().top(); |
|
54 | qreal yMin = height + scaleY * m_domainMinY + geometry().top(); | |
55 | for (int set = 0; set < setCount; set++) { |
|
55 | for (int set = 0; set < setCount; set++) { | |
56 |
QBarSetPrivate* |
|
56 | QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data(); | |
57 |
|
57 | |||
58 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2; |
|
58 | qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2; | |
59 |
|
59 | |||
60 | qreal rectHeight = barSet->value(category) * scaleY; |
|
60 | qreal rectHeight = barSet->value(category) * scaleY; | |
61 |
Bar* |
|
61 | Bar *bar = m_bars.at(itemIndex); | |
62 | bar->setPen(barSet->m_pen); |
|
62 | bar->setPen(barSet->m_pen); | |
63 | bar->setBrush(barSet->m_brush); |
|
63 | bar->setBrush(barSet->m_brush); | |
64 | if (qFuzzyIsNull(rectHeight)) |
|
64 | if (qFuzzyIsNull(rectHeight)) | |
@@ -66,7 +66,7 QVector<QRectF> StackedBarChartItem::calculateLayout() | |||||
66 | else |
|
66 | else | |
67 | bar->setVisible(barsVisible); |
|
67 | bar->setVisible(barsVisible); | |
68 |
|
68 | |||
69 |
QGraphicsSimpleTextItem* |
|
69 | QGraphicsSimpleTextItem *label = m_labels.at(itemIndex); | |
70 |
|
70 | |||
71 | if (!qFuzzyIsNull(barSet->value(category))) |
|
71 | if (!qFuzzyIsNull(barSet->value(category))) | |
72 | label->setText(QString::number(barSet->value(category))); |
|
72 | label->setText(QString::number(barSet->value(category))); |
@@ -27,10 +27,10 | |||||
27 |
|
27 | |||
28 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
28 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
29 |
|
29 | |||
30 |
ChartBackground::ChartBackground(QGraphicsItem* |
|
30 | ChartBackground::ChartBackground(QGraphicsItem *parent) | |
31 | QGraphicsRectItem(parent), |
|
31 | : QGraphicsRectItem(parent), | |
32 | m_diameter(15), |
|
32 | m_diameter(15), | |
33 | m_dropShadow(0) |
|
33 | m_dropShadow(0) | |
34 | { |
|
34 | { | |
35 | } |
|
35 | } | |
36 |
|
36 |
@@ -59,7 +59,7 private: | |||||
59 | m_instance = this; |
|
59 | m_instance = this; | |
60 | } |
|
60 | } | |
61 | public: |
|
61 | public: | |
62 |
static ChartConfig* |
|
62 | static ChartConfig *instance() { | |
63 | if (!m_instance) { |
|
63 | if (!m_instance) { | |
64 | m_instance = new ChartConfig(); |
|
64 | m_instance = new ChartConfig(); | |
65 | } |
|
65 | } | |
@@ -75,11 +75,11 public: | |||||
75 | } |
|
75 | } | |
76 |
|
76 | |||
77 | private: |
|
77 | private: | |
78 |
static ChartConfig* |
|
78 | static ChartConfig *m_instance; | |
79 | }; |
|
79 | }; | |
80 |
|
80 | |||
81 |
|
81 | |||
82 |
ChartConfig* |
|
82 | ChartConfig *ChartConfig::m_instance = 0; | |
83 |
|
83 | |||
84 | QTCOMMERCIALCHART_END_NAMESPACE |
|
84 | QTCOMMERCIALCHART_END_NAMESPACE | |
85 |
|
85 |
@@ -36,7 +36,8 | |||||
36 |
|
36 | |||
37 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
37 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
38 |
|
38 | |||
39 |
ChartDataSet::ChartDataSet(QChart *parent) |
|
39 | ChartDataSet::ChartDataSet(QChart *parent) | |
|
40 | : QObject(parent) | |||
40 | { |
|
41 | { | |
41 |
|
42 | |||
42 | } |
|
43 | } | |
@@ -46,9 +47,9 ChartDataSet::~ChartDataSet() | |||||
46 | removeAllSeries(); |
|
47 | removeAllSeries(); | |
47 | } |
|
48 | } | |
48 |
|
49 | |||
49 |
void ChartDataSet::addSeries(QAbstractSeries* |
|
50 | void ChartDataSet::addSeries(QAbstractSeries *series) | |
50 | { |
|
51 | { | |
51 |
Domain* |
|
52 | Domain *domain = m_seriesDomainMap.value(series); | |
52 |
|
53 | |||
53 | if (domain) { |
|
54 | if (domain) { | |
54 | qWarning() << "Can not add series. Series already on the chart"; |
|
55 | qWarning() << "Can not add series. Series already on the chart"; | |
@@ -62,14 +63,14 void ChartDataSet::addSeries(QAbstractSeries* series) | |||||
62 | createSeriesIndex(series); |
|
63 | createSeriesIndex(series); | |
63 |
|
64 | |||
64 | series->setParent(this); // take ownership |
|
65 | series->setParent(this); // take ownership | |
65 | series->d_ptr->m_chart = qobject_cast<QChart*>(parent()); |
|
66 | series->d_ptr->m_chart = qobject_cast<QChart *>(parent()); | |
66 | series->d_ptr->m_dataset = this; |
|
67 | series->d_ptr->m_dataset = this; | |
67 |
|
68 | |||
68 | emit seriesAdded(series, domain); |
|
69 | emit seriesAdded(series, domain); | |
69 |
|
70 | |||
70 | } |
|
71 | } | |
71 |
|
72 | |||
72 |
void ChartDataSet::removeSeries(QAbstractSeries* |
|
73 | void ChartDataSet::removeSeries(QAbstractSeries *series) | |
73 | { |
|
74 | { | |
74 |
|
75 | |||
75 | if (!m_seriesDomainMap.contains(series)) { |
|
76 | if (!m_seriesDomainMap.contains(series)) { | |
@@ -79,7 +80,7 void ChartDataSet::removeSeries(QAbstractSeries* series) | |||||
79 |
|
80 | |||
80 | emit seriesRemoved(series); |
|
81 | emit seriesRemoved(series); | |
81 |
|
82 | |||
82 |
Domain* |
|
83 | Domain *domain = m_seriesDomainMap.take(series); | |
83 | delete domain; |
|
84 | delete domain; | |
84 | domain = 0; |
|
85 | domain = 0; | |
85 |
|
86 | |||
@@ -94,9 +95,9 void ChartDataSet::removeSeries(QAbstractSeries* series) | |||||
94 |
|
95 | |||
95 |
|
96 | |||
96 |
|
97 | |||
97 |
void ChartDataSet::createSeriesIndex(QAbstractSeries* |
|
98 | void ChartDataSet::createSeriesIndex(QAbstractSeries *series) | |
98 | { |
|
99 | { | |
99 | QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap); |
|
100 | QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap); | |
100 |
|
101 | |||
101 | int key = 0; |
|
102 | int key = 0; | |
102 | while (i.hasNext()) { |
|
103 | while (i.hasNext()) { | |
@@ -109,7 +110,7 void ChartDataSet::createSeriesIndex(QAbstractSeries* series) | |||||
109 | m_indexSeriesMap.insert(key, series); |
|
110 | m_indexSeriesMap.insert(key, series); | |
110 | } |
|
111 | } | |
111 |
|
112 | |||
112 |
void ChartDataSet::removeSeriesIndex(QAbstractSeries* |
|
113 | void ChartDataSet::removeSeriesIndex(QAbstractSeries *series) | |
113 | { |
|
114 | { | |
114 | int key = seriesIndex(series); |
|
115 | int key = seriesIndex(series); | |
115 | Q_ASSERT(key != -1); |
|
116 | Q_ASSERT(key != -1); | |
@@ -125,7 +126,7 void ChartDataSet::createDefaultAxes() | |||||
125 | QAbstractAxis::AxisTypes typeY(0); |
|
126 | QAbstractAxis::AxisTypes typeY(0); | |
126 |
|
127 | |||
127 | // Remove possibly existing axes |
|
128 | // Remove possibly existing axes | |
128 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
129 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
129 | while (i.hasNext()) { |
|
130 | while (i.hasNext()) { | |
130 | i.next(); |
|
131 | i.next(); | |
131 | removeAxes(i.key()); |
|
132 | removeAxes(i.key()); | |
@@ -136,8 +137,8 void ChartDataSet::createDefaultAxes() | |||||
136 | // Select the required axis x and axis y types based on the types of the current series |
|
137 | // Select the required axis x and axis y types based on the types of the current series | |
137 | while (i.hasNext()) { |
|
138 | while (i.hasNext()) { | |
138 | i.next(); |
|
139 | i.next(); | |
139 |
QAbstractAxis* |
|
140 | QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key()); | |
140 |
QAbstractAxis* |
|
141 | QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key()); | |
141 | if (axisX) |
|
142 | if (axisX) | |
142 | typeX &= axisX->type(); |
|
143 | typeX &= axisX->type(); | |
143 | else |
|
144 | else | |
@@ -155,20 +156,20 void ChartDataSet::createDefaultAxes() | |||||
155 |
|
156 | |||
156 | void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation) |
|
157 | void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation) | |
157 | { |
|
158 | { | |
158 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
159 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
159 |
|
160 | |||
160 | // TODO: Add a descriptive comment of what happens here |
|
161 | // TODO: Add a descriptive comment of what happens here | |
161 | if (type.testFlag(QAbstractAxis::AxisTypeValue) && type.testFlag(QAbstractAxis::AxisTypeBarCategory)) { |
|
162 | if (type.testFlag(QAbstractAxis::AxisTypeValue) && type.testFlag(QAbstractAxis::AxisTypeBarCategory)) { | |
162 | while (i.hasNext()) { |
|
163 | while (i.hasNext()) { | |
163 | i.next(); |
|
164 | i.next(); | |
164 |
QAbstractAxis* |
|
165 | QAbstractAxis *axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation); | |
165 | if (axis) { |
|
166 | if (axis) { | |
166 | initializeAxis(axis, i.key()); |
|
167 | initializeAxis(axis, i.key()); | |
167 | emit axisAdded(axis, i.value()); |
|
168 | emit axisAdded(axis, i.value()); | |
168 | } |
|
169 | } | |
169 | } |
|
170 | } | |
170 | } else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) { |
|
171 | } else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) { | |
171 |
QAbstractAxis* |
|
172 | QAbstractAxis *axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation); | |
172 | i.toFront(); |
|
173 | i.toFront(); | |
173 | while (i.hasNext()) { |
|
174 | while (i.hasNext()) { | |
174 | i.next(); |
|
175 | i.next(); | |
@@ -178,9 +179,9 void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation ori | |||||
178 | } |
|
179 | } | |
179 | } |
|
180 | } | |
180 |
|
181 | |||
181 |
QAbstractAxis* |
|
182 | QAbstractAxis *ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation) | |
182 | { |
|
183 | { | |
183 |
QAbstractAxis* |
|
184 | QAbstractAxis *axis = 0; | |
184 |
|
185 | |||
185 | switch (type) { |
|
186 | switch (type) { | |
186 | case QAbstractAxis::AxisTypeValue: |
|
187 | case QAbstractAxis::AxisTypeValue: | |
@@ -208,9 +209,9 QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orient | |||||
208 | return axis; |
|
209 | return axis; | |
209 | } |
|
210 | } | |
210 |
|
211 | |||
211 |
void ChartDataSet::initializeAxis(QAbstractAxis* |
|
212 | void ChartDataSet::initializeAxis(QAbstractAxis *axis, QAbstractSeries *series) | |
212 | { |
|
213 | { | |
213 |
Domain* |
|
214 | Domain *domain = m_seriesDomainMap.value(series); | |
214 | axis->d_ptr->m_dataset = this; |
|
215 | axis->d_ptr->m_dataset = this; | |
215 | series->d_ptr->initializeAxis(axis); |
|
216 | series->d_ptr->initializeAxis(axis); | |
216 | axis->d_ptr->intializeDomain(domain); |
|
217 | axis->d_ptr->intializeDomain(domain); | |
@@ -226,12 +227,12 void ChartDataSet::initializeAxis(QAbstractAxis* axis, QAbstractSeries* series) | |||||
226 | axis->d_ptr->emitUpdated(); |
|
227 | axis->d_ptr->emitUpdated(); | |
227 | } |
|
228 | } | |
228 |
|
229 | |||
229 |
void ChartDataSet::removeAxes(QAbstractSeries* |
|
230 | void ChartDataSet::removeAxes(QAbstractSeries *series) | |
230 | { |
|
231 | { | |
231 |
QAbstractAxis* |
|
232 | QAbstractAxis *axisX = m_seriesAxisXMap.take(series); | |
232 |
|
233 | |||
233 | if (axisX) { |
|
234 | if (axisX) { | |
234 | QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values(); |
|
235 | QList<QAbstractAxis *> axesX = m_seriesAxisXMap.values(); | |
235 | int x = axesX.indexOf(axisX); |
|
236 | int x = axesX.indexOf(axisX); | |
236 |
|
237 | |||
237 | if (x == -1) { |
|
238 | if (x == -1) { | |
@@ -241,10 +242,10 void ChartDataSet::removeAxes(QAbstractSeries* series) | |||||
241 | } |
|
242 | } | |
242 | } |
|
243 | } | |
243 |
|
244 | |||
244 |
QAbstractAxis* |
|
245 | QAbstractAxis *axisY = m_seriesAxisYMap.take(series); | |
245 |
|
246 | |||
246 | if (axisY) { |
|
247 | if (axisY) { | |
247 | QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values(); |
|
248 | QList<QAbstractAxis *> axesY = m_seriesAxisYMap.values(); | |
248 |
|
249 | |||
249 | int y = axesY.indexOf(axisY); |
|
250 | int y = axesY.indexOf(axisY); | |
250 |
|
251 | |||
@@ -256,21 +257,21 void ChartDataSet::removeAxes(QAbstractSeries* series) | |||||
256 | } |
|
257 | } | |
257 | } |
|
258 | } | |
258 |
|
259 | |||
259 |
void ChartDataSet::removeAxis(QAbstractAxis* |
|
260 | void ChartDataSet::removeAxis(QAbstractAxis *axis) | |
260 | { |
|
261 | { | |
261 | if (!axis->d_ptr->m_dataset) { |
|
262 | if (!axis->d_ptr->m_dataset) { | |
262 | qWarning() << "UnBound axis found !"; |
|
263 | qWarning() << "UnBound axis found !"; | |
263 | return; |
|
264 | return; | |
264 | } |
|
265 | } | |
265 |
|
266 | |||
266 | QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap; |
|
267 | QMap<QAbstractSeries *, QAbstractAxis *> *seriesAxisMap; | |
267 |
|
268 | |||
268 | if (axis->orientation() == Qt::Vertical) |
|
269 | if (axis->orientation() == Qt::Vertical) | |
269 | seriesAxisMap = &m_seriesAxisYMap; |
|
270 | seriesAxisMap = &m_seriesAxisYMap; | |
270 | else |
|
271 | else | |
271 | seriesAxisMap = &m_seriesAxisXMap; |
|
272 | seriesAxisMap = &m_seriesAxisXMap; | |
272 |
|
273 | |||
273 | QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap); |
|
274 | QMapIterator<QAbstractSeries *, QAbstractAxis *> i(*seriesAxisMap); | |
274 |
|
275 | |||
275 | while (i.hasNext()) { |
|
276 | while (i.hasNext()) { | |
276 | i.next(); |
|
277 | i.next(); | |
@@ -292,14 +293,14 void ChartDataSet::removeAllSeries() | |||||
292 | qDeleteAll(series); |
|
293 | qDeleteAll(series); | |
293 | } |
|
294 | } | |
294 |
|
295 | |||
295 |
void ChartDataSet::zoomInDomain(const QRectF& |
|
296 | void ChartDataSet::zoomInDomain(const QRectF &rect, const QSizeF &size) | |
296 | { |
|
297 | { | |
297 | //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates |
|
298 | //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates | |
298 |
|
299 | |||
299 |
|
300 | |||
300 | blockAxisSignals(true); |
|
301 | blockAxisSignals(true); | |
301 |
|
302 | |||
302 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
303 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
303 |
|
304 | |||
304 | while (i.hasNext()) { |
|
305 | while (i.hasNext()) { | |
305 | i.next(); |
|
306 | i.next(); | |
@@ -310,13 +311,13 void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size) | |||||
310 |
|
311 | |||
311 | } |
|
312 | } | |
312 |
|
313 | |||
313 |
void ChartDataSet::zoomOutDomain(const QRectF& |
|
314 | void ChartDataSet::zoomOutDomain(const QRectF &rect, const QSizeF &size) | |
314 | { |
|
315 | { | |
315 | //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates |
|
316 | //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates | |
316 |
|
317 | |||
317 | blockAxisSignals(true); |
|
318 | blockAxisSignals(true); | |
318 |
|
319 | |||
319 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
320 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
320 |
|
321 | |||
321 | while (i.hasNext()) { |
|
322 | while (i.hasNext()) { | |
322 | i.next(); |
|
323 | i.next(); | |
@@ -328,11 +329,11 void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size) | |||||
328 |
|
329 | |||
329 | void ChartDataSet::blockAxisSignals(bool enabled) |
|
330 | void ChartDataSet::blockAxisSignals(bool enabled) | |
330 | { |
|
331 | { | |
331 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
332 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
332 | while (i.hasNext()) { |
|
333 | while (i.hasNext()) { | |
333 | i.next(); |
|
334 | i.next(); | |
334 |
QAbstractAxis* |
|
335 | QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key()); | |
335 |
QAbstractAxis* |
|
336 | QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key()); | |
336 | if (axisX) { |
|
337 | if (axisX) { | |
337 | axisX->d_ptr->blockSignals(enabled); |
|
338 | axisX->d_ptr->blockSignals(enabled); | |
338 | if (!enabled) { |
|
339 | if (!enabled) { | |
@@ -353,7 +354,7 void ChartDataSet::blockAxisSignals(bool enabled) | |||||
353 | int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type) |
|
354 | int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type) | |
354 | { |
|
355 | { | |
355 | int count = 0; |
|
356 | int count = 0; | |
356 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
357 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
357 | while (i.hasNext()) { |
|
358 | while (i.hasNext()) { | |
358 | i.next(); |
|
359 | i.next(); | |
359 | if (i.key()->type() == type) |
|
360 | if (i.key()->type() == type) | |
@@ -364,7 +365,7 int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type) | |||||
364 |
|
365 | |||
365 | int ChartDataSet::seriesIndex(QAbstractSeries *series) |
|
366 | int ChartDataSet::seriesIndex(QAbstractSeries *series) | |
366 | { |
|
367 | { | |
367 | QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap); |
|
368 | QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap); | |
368 | while (i.hasNext()) { |
|
369 | while (i.hasNext()) { | |
369 | i.next(); |
|
370 | i.next(); | |
370 | if (i.value() == series) |
|
371 | if (i.value() == series) | |
@@ -373,11 +374,11 int ChartDataSet::seriesIndex(QAbstractSeries *series) | |||||
373 | return -1; |
|
374 | return -1; | |
374 | } |
|
375 | } | |
375 |
|
376 | |||
376 |
QAbstractAxis* |
|
377 | QAbstractAxis *ChartDataSet::axisX(QAbstractSeries *series) const | |
377 | { |
|
378 | { | |
378 | if (series == 0) { |
|
379 | if (series == 0) { | |
379 |
|
380 | |||
380 | QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap); |
|
381 | QMapIterator<QAbstractSeries *, QAbstractAxis *> i(m_seriesAxisXMap); | |
381 |
|
382 | |||
382 | while (i.hasNext()) { |
|
383 | while (i.hasNext()) { | |
383 | i.next(); |
|
384 | i.next(); | |
@@ -389,10 +390,10 QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const | |||||
389 | return m_seriesAxisXMap.value(series); |
|
390 | return m_seriesAxisXMap.value(series); | |
390 | } |
|
391 | } | |
391 |
|
392 | |||
392 |
QAbstractAxis* |
|
393 | QAbstractAxis *ChartDataSet::axisY(QAbstractSeries *series) const | |
393 | { |
|
394 | { | |
394 | if (series == 0) { |
|
395 | if (series == 0) { | |
395 | QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap); |
|
396 | QMapIterator<QAbstractSeries *, QAbstractAxis *> i(m_seriesAxisYMap); | |
396 |
|
397 | |||
397 | while (i.hasNext()) { |
|
398 | while (i.hasNext()) { | |
398 | i.next(); |
|
399 | i.next(); | |
@@ -412,7 +413,7 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Ori | |||||
412 | return; |
|
413 | return; | |
413 | } |
|
414 | } | |
414 |
|
415 | |||
415 |
Domain* |
|
416 | Domain *domain = m_seriesDomainMap.value(series); | |
416 |
|
417 | |||
417 | if (!domain) { |
|
418 | if (!domain) { | |
418 | qWarning() << "Series not found on the chart."; |
|
419 | qWarning() << "Series not found on the chart."; | |
@@ -431,7 +432,7 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Ori | |||||
431 |
|
432 | |||
432 | axis->d_ptr->setOrientation(orientation); |
|
433 | axis->d_ptr->setOrientation(orientation); | |
433 |
|
434 | |||
434 | QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap; |
|
435 | QMap<QAbstractSeries *, QAbstractAxis *> *seriesAxisMap; | |
435 |
|
436 | |||
436 | if (orientation == Qt::Vertical) |
|
437 | if (orientation == Qt::Vertical) | |
437 | seriesAxisMap = &m_seriesAxisYMap; |
|
438 | seriesAxisMap = &m_seriesAxisYMap; | |
@@ -444,7 +445,7 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Ori | |||||
444 | } |
|
445 | } | |
445 |
|
446 | |||
446 | QAbstractAxis *oldAxis = seriesAxisMap->take(series); |
|
447 | QAbstractAxis *oldAxis = seriesAxisMap->take(series); | |
447 | QList<QAbstractAxis*> axes = seriesAxisMap->values(); |
|
448 | QList<QAbstractAxis *> axes = seriesAxisMap->values(); | |
448 | if (oldAxis) { |
|
449 | if (oldAxis) { | |
449 | if (axes.indexOf(oldAxis) == -1) { |
|
450 | if (axes.indexOf(oldAxis) == -1) { | |
450 | emit axisRemoved(oldAxis); |
|
451 | emit axisRemoved(oldAxis); | |
@@ -463,15 +464,15 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Ori | |||||
463 | } |
|
464 | } | |
464 | } |
|
465 | } | |
465 |
|
466 | |||
466 |
Domain* |
|
467 | Domain *ChartDataSet::domain(QAbstractSeries *series) const | |
467 | { |
|
468 | { | |
468 | return m_seriesDomainMap.value(series); |
|
469 | return m_seriesDomainMap.value(series); | |
469 | } |
|
470 | } | |
470 |
|
471 | |||
471 |
void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF& |
|
472 | void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF &size) | |
472 | { |
|
473 | { | |
473 | blockAxisSignals(true); |
|
474 | blockAxisSignals(true); | |
474 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
475 | QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap); | |
475 | while (i.hasNext()) { |
|
476 | while (i.hasNext()) { | |
476 | i.next(); |
|
477 | i.next(); | |
477 | i.value()->move(dx, dy, size); |
|
478 | i.value()->move(dx, dy, size); | |
@@ -479,7 +480,7 void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF& size) | |||||
479 | blockAxisSignals(false); |
|
480 | blockAxisSignals(false); | |
480 | } |
|
481 | } | |
481 |
|
482 | |||
482 | QList<QAbstractSeries*> ChartDataSet::series() const |
|
483 | QList<QAbstractSeries *> ChartDataSet::series() const | |
483 | { |
|
484 | { | |
484 | return m_seriesDomainMap.keys(); |
|
485 | return m_seriesDomainMap.keys(); | |
485 | } |
|
486 | } |
@@ -43,54 +43,54 class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject | |||||
43 | { |
|
43 | { | |
44 | Q_OBJECT |
|
44 | Q_OBJECT | |
45 | public: |
|
45 | public: | |
46 |
ChartDataSet(QChart* |
|
46 | ChartDataSet(QChart *parent = 0); | |
47 | virtual ~ChartDataSet(); |
|
47 | virtual ~ChartDataSet(); | |
48 |
|
48 | |||
49 |
void addSeries(QAbstractSeries* |
|
49 | void addSeries(QAbstractSeries *series); | |
50 |
void removeSeries(QAbstractSeries* |
|
50 | void removeSeries(QAbstractSeries *series); | |
51 | void removeAllSeries(); |
|
51 | void removeAllSeries(); | |
52 | // void updateSeries(QAbstractSeries* series); |
|
52 | // void updateSeries(QAbstractSeries* series); | |
53 |
|
53 | |||
54 |
void zoomInDomain(const QRectF& |
|
54 | void zoomInDomain(const QRectF &rect, const QSizeF &size); | |
55 |
void zoomOutDomain(const QRectF& |
|
55 | void zoomOutDomain(const QRectF &rect, const QSizeF &size); | |
56 |
void scrollDomain(qreal dx, qreal dy, const QSizeF& |
|
56 | void scrollDomain(qreal dx, qreal dy, const QSizeF &size); | |
57 |
|
57 | |||
58 | int seriesCount(QAbstractSeries::SeriesType type); |
|
58 | int seriesCount(QAbstractSeries::SeriesType type); | |
59 | int seriesIndex(QAbstractSeries *series); |
|
59 | int seriesIndex(QAbstractSeries *series); | |
60 |
|
60 | |||
61 |
QAbstractAxis* |
|
61 | QAbstractAxis *axisX(QAbstractSeries *series) const; | |
62 |
QAbstractAxis* |
|
62 | QAbstractAxis *axisY(QAbstractSeries *series) const; | |
63 |
|
63 | |||
64 | void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation); |
|
64 | void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation); | |
65 |
|
65 | |||
66 | QList<QAbstractSeries*> series() const; |
|
66 | QList<QAbstractSeries *> series() const; | |
67 |
Domain* |
|
67 | Domain *domain(QAbstractSeries *series) const; | |
68 |
|
68 | |||
69 |
void removeAxis(QAbstractAxis* |
|
69 | void removeAxis(QAbstractAxis *axis); | |
70 | void createDefaultAxes(); |
|
70 | void createDefaultAxes(); | |
71 |
|
71 | |||
72 | Q_SIGNALS: |
|
72 | Q_SIGNALS: | |
73 |
void seriesAdded(QAbstractSeries* |
|
73 | void seriesAdded(QAbstractSeries *series, Domain *domain); | |
74 |
void seriesRemoved(QAbstractSeries* |
|
74 | void seriesRemoved(QAbstractSeries *series); | |
75 | // void seriesUpdated(QAbstractSeries* series); |
|
75 | // void seriesUpdated(QAbstractSeries* series); | |
76 |
void axisAdded(QAbstractAxis* |
|
76 | void axisAdded(QAbstractAxis *axis, Domain *domain); | |
77 |
void axisRemoved(QAbstractAxis* |
|
77 | void axisRemoved(QAbstractAxis *axis); | |
78 |
|
78 | |||
79 | private: |
|
79 | private: | |
80 |
void calculateDomain(QAbstractSeries* |
|
80 | void calculateDomain(QAbstractSeries *series, Domain *domain); | |
81 | void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation); |
|
81 | void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation); | |
82 |
QAbstractAxis* |
|
82 | QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation); | |
83 |
void initializeAxis(QAbstractAxis* |
|
83 | void initializeAxis(QAbstractAxis *axis, QAbstractSeries *series); | |
84 |
void removeAxes(QAbstractSeries* |
|
84 | void removeAxes(QAbstractSeries *series); | |
85 | void blockAxisSignals(bool enabled); |
|
85 | void blockAxisSignals(bool enabled); | |
86 |
void createSeriesIndex(QAbstractSeries* |
|
86 | void createSeriesIndex(QAbstractSeries *series); | |
87 |
void removeSeriesIndex(QAbstractSeries* |
|
87 | void removeSeriesIndex(QAbstractSeries *series); | |
88 |
|
88 | |||
89 | private: |
|
89 | private: | |
90 | QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisXMap; |
|
90 | QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisXMap; | |
91 | QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisYMap; |
|
91 | QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisYMap; | |
92 | QMap<QAbstractSeries*, Domain*> m_seriesDomainMap; |
|
92 | QMap<QAbstractSeries *, Domain *> m_seriesDomainMap; | |
93 | QMap<int, QAbstractSeries*> m_indexSeriesMap; |
|
93 | QMap<int, QAbstractSeries *> m_indexSeriesMap; | |
94 | }; |
|
94 | }; | |
95 |
|
95 | |||
96 | QTCOMMERCIALCHART_END_NAMESPACE |
|
96 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -36,7 +36,7 void ChartElement::setPresenter(ChartPresenter *presenter) | |||||
36 | m_presenter = presenter; |
|
36 | m_presenter = presenter; | |
37 | } |
|
37 | } | |
38 |
|
38 | |||
39 |
ChartPresenter* |
|
39 | ChartPresenter *ChartElement::presenter() const | |
40 | { |
|
40 | { | |
41 | return m_presenter; |
|
41 | return m_presenter; | |
42 | } |
|
42 | } | |
@@ -46,12 +46,12 void ChartElement::setDomain(Domain *domain) | |||||
46 | m_domain = domain; |
|
46 | m_domain = domain; | |
47 | } |
|
47 | } | |
48 |
|
48 | |||
49 |
Domain* |
|
49 | Domain *ChartElement::domain() const | |
50 | { |
|
50 | { | |
51 | return m_domain; |
|
51 | return m_domain; | |
52 | } |
|
52 | } | |
53 |
|
53 | |||
54 |
void ChartElement::handleGeometryChanged(const QRectF& |
|
54 | void ChartElement::handleGeometryChanged(const QRectF &rect) | |
55 | { |
|
55 | { | |
56 | Q_UNUSED(rect); |
|
56 | Q_UNUSED(rect); | |
57 | qWarning() << "Slot not implemented"; |
|
57 | qWarning() << "Slot not implemented"; |
@@ -48,20 +48,19 public: | |||||
48 | explicit ChartElement(ChartPresenter *presenter); |
|
48 | explicit ChartElement(ChartPresenter *presenter); | |
49 |
|
49 | |||
50 | public Q_SLOTS: |
|
50 | public Q_SLOTS: | |
51 |
virtual void handleGeometryChanged(const QRectF& |
|
51 | virtual void handleGeometryChanged(const QRectF &rect); | |
52 | virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY); |
|
52 | virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY); | |
53 | virtual void handleDomainUpdated(); |
|
53 | virtual void handleDomainUpdated(); | |
54 |
virtual ChartAnimation* |
|
54 | virtual ChartAnimation *animation() const { return 0; } | |
55 |
|
55 | |||
56 | void setPresenter(ChartPresenter *presenter); |
|
56 | void setPresenter(ChartPresenter *presenter); | |
57 |
ChartPresenter* |
|
57 | ChartPresenter *presenter() const; | |
58 | void setDomain(Domain *domain); |
|
58 | void setDomain(Domain *domain); | |
59 |
Domain* |
|
59 | Domain *domain() const; | |
60 |
|
||||
61 |
|
60 | |||
62 | private: |
|
61 | private: | |
63 |
ChartPresenter* |
|
62 | ChartPresenter *m_presenter; | |
64 |
Domain* |
|
63 | Domain *m_domain; | |
65 | }; |
|
64 | }; | |
66 |
|
65 | |||
67 | QTCOMMERCIALCHART_END_NAMESPACE |
|
66 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -30,7 +30,7 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
30 |
|
30 | |||
31 | static const qreal golden_ratio = 0.25; |
|
31 | static const qreal golden_ratio = 0.25; | |
32 |
|
32 | |||
33 |
ChartLayout::ChartLayout(ChartPresenter* |
|
33 | ChartLayout::ChartLayout(ChartPresenter *presenter) | |
34 | : m_presenter(presenter), |
|
34 | : m_presenter(presenter), | |
35 | m_margins(20, 20, 20, 20), |
|
35 | m_margins(20, 20, 20, 20), | |
36 | m_minChartRect(0, 0, 200, 200) |
|
36 | m_minChartRect(0, 0, 200, 200) | |
@@ -43,15 +43,15 ChartLayout::~ChartLayout() | |||||
43 |
|
43 | |||
44 | } |
|
44 | } | |
45 |
|
45 | |||
46 |
void ChartLayout::setGeometry(const QRectF& |
|
46 | void ChartLayout::setGeometry(const QRectF &rect) | |
47 | { |
|
47 | { | |
48 | if (!rect.isValid()) |
|
48 | if (!rect.isValid()) | |
49 | return; |
|
49 | return; | |
50 |
|
50 | |||
51 | QList<ChartAxis*> axes = m_presenter->axisItems(); |
|
51 | QList<ChartAxis *> axes = m_presenter->axisItems(); | |
52 |
ChartTitle* |
|
52 | ChartTitle *title = m_presenter->titleElement(); | |
53 |
QLegend* |
|
53 | QLegend *legend = m_presenter->legend(); | |
54 |
ChartBackground* |
|
54 | ChartBackground *background = m_presenter->backgroundElement(); | |
55 |
|
55 | |||
56 | QRectF contentGeometry = calculateBackgroundGeometry(rect, background); |
|
56 | QRectF contentGeometry = calculateBackgroundGeometry(rect, background); | |
57 |
|
57 | |||
@@ -67,7 +67,7 void ChartLayout::setGeometry(const QRectF& rect) | |||||
67 |
|
67 | |||
68 | //TODO remove me |
|
68 | //TODO remove me | |
69 | #ifdef SHOW_LAYOUT |
|
69 | #ifdef SHOW_LAYOUT | |
70 |
LayoutDebuger* |
|
70 | LayoutDebuger *debuger = LayoutDebuger::instance(); | |
71 | debuger->reset(); |
|
71 | debuger->reset(); | |
72 | debuger->setPen(QPen(Qt::red)); |
|
72 | debuger->setPen(QPen(Qt::red)); | |
73 | debuger->add(backgroundGeometry, m_presenter->rootItem()); |
|
73 | debuger->add(backgroundGeometry, m_presenter->rootItem()); | |
@@ -75,25 +75,25 void ChartLayout::setGeometry(const QRectF& rect) | |||||
75 | debuger->add(legendGeometry , m_presenter->rootItem()); |
|
75 | debuger->add(legendGeometry , m_presenter->rootItem()); | |
76 | debuger->add(axisGeometry , m_presenter->rootItem()); |
|
76 | debuger->add(axisGeometry , m_presenter->rootItem()); | |
77 | debuger->add(geometry, m_presenter->rootItem()); |
|
77 | debuger->add(geometry, m_presenter->rootItem()); | |
78 |
foreach |
|
78 | foreach(LegendMarker * marker, legend->d_ptr->markers()) | |
79 |
|
|
79 | debuger->add(marker->mapRectToScene(marker->boundingRect()), m_presenter->rootItem()); | |
80 | #endif |
|
80 | #endif | |
81 |
|
81 | |||
82 | QGraphicsLayout::setGeometry(rect); |
|
82 | QGraphicsLayout::setGeometry(rect); | |
83 | } |
|
83 | } | |
84 |
|
84 | |||
85 |
QRectF ChartLayout::calculateContentGeometry(const QRectF& |
|
85 | QRectF ChartLayout::calculateContentGeometry(const QRectF &geometry) const | |
86 | { |
|
86 | { | |
87 | return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom()); |
|
87 | return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom()); | |
88 | } |
|
88 | } | |
89 |
|
89 | |||
90 |
QRectF ChartLayout::calculateContentMinimum(const QRectF& |
|
90 | QRectF ChartLayout::calculateContentMinimum(const QRectF &minimum) const | |
91 | { |
|
91 | { | |
92 | return minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom()); |
|
92 | return minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom()); | |
93 | } |
|
93 | } | |
94 |
|
94 | |||
95 |
|
95 | |||
96 |
QRectF ChartLayout::calculateBackgroundGeometry(const QRectF& |
|
96 | QRectF ChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const | |
97 | { |
|
97 | { | |
98 | qreal left, top, right, bottom; |
|
98 | qreal left, top, right, bottom; | |
99 | getContentsMargins(&left, &top, &right, &bottom); |
|
99 | getContentsMargins(&left, &top, &right, &bottom); | |
@@ -103,14 +103,14 QRectF ChartLayout::calculateBackgroundGeometry(const QRectF& geometry, ChartBac | |||||
103 | return backgroundGeometry; |
|
103 | return backgroundGeometry; | |
104 | } |
|
104 | } | |
105 |
|
105 | |||
106 |
QRectF ChartLayout::calculateBackgroundMinimum(const QRectF& |
|
106 | QRectF ChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const | |
107 | { |
|
107 | { | |
108 | qreal left, top, right, bottom; |
|
108 | qreal left, top, right, bottom; | |
109 | getContentsMargins(&left, &top, &right, &bottom); |
|
109 | getContentsMargins(&left, &top, &right, &bottom); | |
110 | return minimum.adjusted(0, 0, left + right, top + bottom); |
|
110 | return minimum.adjusted(0, 0, left + right, top + bottom); | |
111 | } |
|
111 | } | |
112 |
|
112 | |||
113 |
QRectF ChartLayout::calculateChartGeometry(const QRectF& |
|
113 | QRectF ChartLayout::calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const | |
114 | { |
|
114 | { | |
115 |
|
115 | |||
116 | QSizeF vertical(0, 0); |
|
116 | QSizeF vertical(0, 0); | |
@@ -122,7 +122,7 QRectF ChartLayout::calculateChartGeometry(const QRectF& geometry, const QList<C | |||||
122 | int rightAxisCount = 0; |
|
122 | int rightAxisCount = 0; | |
123 |
|
123 | |||
124 | // check axis size |
|
124 | // check axis size | |
125 |
foreach (ChartAxis* |
|
125 | foreach (ChartAxis *axis , axes) { | |
126 | if (axis->orientation() == Qt::Vertical && axis->isVisible()) { |
|
126 | if (axis->orientation() == Qt::Vertical && axis->isVisible()) { | |
127 | // vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize)); |
|
127 | // vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize)); | |
128 | if (axis->alternativePlacement()) |
|
128 | if (axis->alternativePlacement()) | |
@@ -177,7 +177,7 QRectF ChartLayout::calculateChartGeometry(const QRectF& geometry, const QList<C | |||||
177 | return rect; |
|
177 | return rect; | |
178 | } |
|
178 | } | |
179 |
|
179 | |||
180 |
QRectF ChartLayout::calculateAxisMinimum(const QRectF& |
|
180 | QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const | |
181 | { |
|
181 | { | |
182 | QSizeF vertical(0, 0); |
|
182 | QSizeF vertical(0, 0); | |
183 | QSizeF horizontal(0, 0); |
|
183 | QSizeF horizontal(0, 0); | |
@@ -192,7 +192,7 QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<Char | |||||
192 | return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height()); |
|
192 | return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height()); | |
193 | } |
|
193 | } | |
194 |
|
194 | |||
195 |
QRectF ChartLayout::calculateLegendGeometry(const QRectF& |
|
195 | QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const | |
196 | { |
|
196 | { | |
197 | QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)); |
|
197 | QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)); | |
198 | QRectF legendRect; |
|
198 | QRectF legendRect; | |
@@ -230,13 +230,13 QRectF ChartLayout::calculateLegendGeometry(const QRectF& geometry, QLegend* leg | |||||
230 | return result; |
|
230 | return result; | |
231 | } |
|
231 | } | |
232 |
|
232 | |||
233 |
QRectF ChartLayout::calculateLegendMinimum(const QRectF& |
|
233 | QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const | |
234 | { |
|
234 | { | |
235 | QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)); |
|
235 | QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)); | |
236 | return geometry.adjusted(0, 0, minSize.width(), minSize.height()); |
|
236 | return geometry.adjusted(0, 0, minSize.width(), minSize.height()); | |
237 | } |
|
237 | } | |
238 |
|
238 | |||
239 |
QRectF ChartLayout::calculateTitleGeometry(const QRectF& |
|
239 | QRectF ChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const | |
240 | { |
|
240 | { | |
241 | title->setGeometry(geometry); |
|
241 | title->setGeometry(geometry); | |
242 | QPointF center = geometry.center() - title->boundingRect().center(); |
|
242 | QPointF center = geometry.center() - title->boundingRect().center(); | |
@@ -244,19 +244,19 QRectF ChartLayout::calculateTitleGeometry(const QRectF& geometry, ChartTitle* t | |||||
244 | return geometry.adjusted(0, title->boundingRect().height(), 0, 0); |
|
244 | return geometry.adjusted(0, title->boundingRect().height(), 0, 0); | |
245 | } |
|
245 | } | |
246 |
|
246 | |||
247 |
QRectF ChartLayout::calculateTitleMinimum(const QRectF& |
|
247 | QRectF ChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const | |
248 | { |
|
248 | { | |
249 | QSizeF min = title->sizeHint(Qt::MinimumSize); |
|
249 | QSizeF min = title->sizeHint(Qt::MinimumSize); | |
250 | return minimum.adjusted(0, 0, min.width(), min.height()); |
|
250 | return minimum.adjusted(0, 0, min.width(), min.height()); | |
251 | } |
|
251 | } | |
252 |
|
252 | |||
253 |
QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF & |
|
253 | QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
254 | { |
|
254 | { | |
255 | Q_UNUSED(constraint); |
|
255 | Q_UNUSED(constraint); | |
256 | if (which == Qt::MinimumSize) { |
|
256 | if (which == Qt::MinimumSize) { | |
257 | QList<ChartAxis*> axes = m_presenter->axisItems(); |
|
257 | QList<ChartAxis *> axes = m_presenter->axisItems(); | |
258 |
ChartTitle* |
|
258 | ChartTitle *title = m_presenter->titleElement(); | |
259 |
QLegend* |
|
259 | QLegend *legend = m_presenter->legend(); | |
260 | QRectF minimumRect(0, 0, 0, 0); |
|
260 | QRectF minimumRect(0, 0, 0, 0); | |
261 | minimumRect = calculateBackgroundMinimum(minimumRect); |
|
261 | minimumRect = calculateBackgroundMinimum(minimumRect); | |
262 | minimumRect = calculateContentMinimum(minimumRect); |
|
262 | minimumRect = calculateContentMinimum(minimumRect); | |
@@ -268,7 +268,7 QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF & constraint) cons | |||||
268 | return QSize(-1, -1); |
|
268 | return QSize(-1, -1); | |
269 | } |
|
269 | } | |
270 |
|
270 | |||
271 |
void ChartLayout::setMargins(const QMargins& |
|
271 | void ChartLayout::setMargins(const QMargins &margins) | |
272 | { |
|
272 | { | |
273 | if (m_margins != margins) { |
|
273 | if (m_margins != margins) { | |
274 | m_margins = margins; |
|
274 | m_margins = margins; |
@@ -36,35 +36,35 class ChartLayout : public QGraphicsLayout | |||||
36 | { |
|
36 | { | |
37 | public: |
|
37 | public: | |
38 |
|
38 | |||
39 |
ChartLayout(ChartPresenter* |
|
39 | ChartLayout(ChartPresenter *presenter); | |
40 | virtual ~ChartLayout(); |
|
40 | virtual ~ChartLayout(); | |
41 |
|
41 | |||
42 |
void setMargins(const QMargins& |
|
42 | void setMargins(const QMargins &margins); | |
43 | QMargins margins() const; |
|
43 | QMargins margins() const; | |
44 |
|
44 | |||
45 |
void setGeometry(const QRectF& |
|
45 | void setGeometry(const QRectF &rect); | |
46 | void adjustChartGeometry(); |
|
46 | void adjustChartGeometry(); | |
47 |
|
47 | |||
48 | protected: |
|
48 | protected: | |
49 |
QSizeF sizeHint |
|
49 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const; | |
50 | int count() const { return 0; } |
|
50 | int count() const { return 0; } | |
51 |
QGraphicsLayoutItem* |
|
51 | QGraphicsLayoutItem *itemAt(int) const { return 0; }; | |
52 | void removeAt(int){}; |
|
52 | void removeAt(int) {}; | |
53 |
|
53 | |||
54 | private: |
|
54 | private: | |
55 |
QRectF calculateBackgroundGeometry(const QRectF& |
|
55 | QRectF calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const; | |
56 |
QRectF calculateContentGeometry(const QRectF& |
|
56 | QRectF calculateContentGeometry(const QRectF &geometry) const; | |
57 |
QRectF calculateTitleGeometry(const QRectF& |
|
57 | QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const; | |
58 |
QRectF calculateChartGeometry(const QRectF& |
|
58 | QRectF calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const; | |
59 |
QRectF calculateLegendGeometry(const QRectF& |
|
59 | QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const; | |
60 |
QRectF calculateBackgroundMinimum(const QRectF& |
|
60 | QRectF calculateBackgroundMinimum(const QRectF &minimum) const; | |
61 |
QRectF calculateContentMinimum(const QRectF& |
|
61 | QRectF calculateContentMinimum(const QRectF &minimum) const; | |
62 |
QRectF calculateTitleMinimum(const QRectF& |
|
62 | QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const; | |
63 |
QRectF calculateAxisMinimum(const QRectF& |
|
63 | QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const; | |
64 |
QRectF calculateLegendMinimum(const QRectF& |
|
64 | QRectF calculateLegendMinimum(const QRectF &minimum, QLegend *legend) const; | |
65 |
|
65 | |||
66 | private: |
|
66 | private: | |
67 |
ChartPresenter* |
|
67 | ChartPresenter *m_presenter; | |
68 | QMargins m_margins; |
|
68 | QMargins m_margins; | |
69 | QRectF m_minChartRect; |
|
69 | QRectF m_minChartRect; | |
70 | QRectF m_minAxisRect; |
|
70 | QRectF m_minAxisRect; |
@@ -35,7 +35,7 | |||||
35 |
|
35 | |||
36 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
36 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
37 |
|
37 | |||
38 |
ChartPresenter::ChartPresenter(QChart* |
|
38 | ChartPresenter::ChartPresenter(QChart *chart, ChartDataSet *dataset) | |
39 | : QObject(chart), |
|
39 | : QObject(chart), | |
40 | m_chart(chart), |
|
40 | m_chart(chart), | |
41 | m_dataset(dataset), |
|
41 | m_dataset(dataset), | |
@@ -54,7 +54,7 ChartPresenter::~ChartPresenter() | |||||
54 | delete m_chartTheme; |
|
54 | delete m_chartTheme; | |
55 | } |
|
55 | } | |
56 |
|
56 | |||
57 |
void ChartPresenter::setChartsGeometry(const QRectF& |
|
57 | void ChartPresenter::setChartsGeometry(const QRectF &rect) | |
58 | { |
|
58 | { | |
59 | Q_ASSERT(rect.isValid()); |
|
59 | Q_ASSERT(rect.isValid()); | |
60 |
|
60 | |||
@@ -70,9 +70,9 QRectF ChartPresenter::chartsGeometry() const | |||||
70 | return m_chartsRect; |
|
70 | return m_chartsRect; | |
71 | } |
|
71 | } | |
72 |
|
72 | |||
73 |
void ChartPresenter::handleAxisAdded(QAbstractAxis* |
|
73 | void ChartPresenter::handleAxisAdded(QAbstractAxis *axis, Domain *domain) | |
74 | { |
|
74 | { | |
75 |
ChartAxis* |
|
75 | ChartAxis *item = axis->d_ptr->createGraphics(this); | |
76 | item->setDomain(domain); |
|
76 | item->setDomain(domain); | |
77 |
|
77 | |||
78 | if (m_options.testFlag(QChart::GridAxisAnimations)) |
|
78 | if (m_options.testFlag(QChart::GridAxisAnimations)) | |
@@ -94,9 +94,9 void ChartPresenter::handleAxisAdded(QAbstractAxis* axis, Domain* domain) | |||||
94 | selectVisibleAxis(); |
|
94 | selectVisibleAxis(); | |
95 | } |
|
95 | } | |
96 |
|
96 | |||
97 |
void ChartPresenter::handleAxisRemoved(QAbstractAxis* |
|
97 | void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis) | |
98 | { |
|
98 | { | |
99 |
ChartAxis* |
|
99 | ChartAxis *item = m_axisItems.take(axis); | |
100 | Q_ASSERT(item); |
|
100 | Q_ASSERT(item); | |
101 | selectVisibleAxis(); |
|
101 | selectVisibleAxis(); | |
102 | item->hide(); |
|
102 | item->hide(); | |
@@ -106,7 +106,7 void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis) | |||||
106 | } |
|
106 | } | |
107 |
|
107 | |||
108 |
|
108 | |||
109 |
void ChartPresenter::handleSeriesAdded(QAbstractSeries* |
|
109 | void ChartPresenter::handleSeriesAdded(QAbstractSeries *series, Domain *domain) | |
110 | { |
|
110 | { | |
111 | ChartElement *item = series->d_ptr->createGraphics(this); |
|
111 | ChartElement *item = series->d_ptr->createGraphics(this); | |
112 | Q_ASSERT(item); |
|
112 | Q_ASSERT(item); | |
@@ -122,16 +122,16 void ChartPresenter::handleSeriesAdded(QAbstractSeries* series, Domain* domain) | |||||
122 | m_chartItems.insert(series, item); |
|
122 | m_chartItems.insert(series, item); | |
123 | } |
|
123 | } | |
124 |
|
124 | |||
125 |
void ChartPresenter::handleSeriesRemoved(QAbstractSeries* |
|
125 | void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series) | |
126 | { |
|
126 | { | |
127 |
ChartElement* |
|
127 | ChartElement *item = m_chartItems.take(series); | |
128 | Q_ASSERT(item); |
|
128 | Q_ASSERT(item); | |
129 | item->deleteLater(); |
|
129 | item->deleteLater(); | |
130 | } |
|
130 | } | |
131 |
|
131 | |||
132 | void ChartPresenter::selectVisibleAxis() |
|
132 | void ChartPresenter::selectVisibleAxis() | |
133 | { |
|
133 | { | |
134 | QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems); |
|
134 | QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems); | |
135 |
|
135 | |||
136 | while (i.hasNext()) { |
|
136 | while (i.hasNext()) { | |
137 | i.next(); |
|
137 | i.next(); | |
@@ -161,11 +161,11 void ChartPresenter::selectVisibleAxis() | |||||
161 |
|
161 | |||
162 | void ChartPresenter::handleAxisVisibleChanged(bool visible) |
|
162 | void ChartPresenter::handleAxisVisibleChanged(bool visible) | |
163 | { |
|
163 | { | |
164 |
QAbstractAxis* |
|
164 | QAbstractAxis *axis = static_cast<QAbstractAxis *>(sender()); | |
165 | Q_ASSERT(axis); |
|
165 | Q_ASSERT(axis); | |
166 | if (visible) { |
|
166 | if (visible) { | |
167 |
|
167 | |||
168 | QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems); |
|
168 | QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems); | |
169 |
|
169 | |||
170 | while (i.hasNext()) { |
|
170 | while (i.hasNext()) { | |
171 | i.next(); |
|
171 | i.next(); | |
@@ -210,20 +210,20 void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options) | |||||
210 |
|
210 | |||
211 | void ChartPresenter::resetAllElements() |
|
211 | void ChartPresenter::resetAllElements() | |
212 | { |
|
212 | { | |
213 | QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems); |
|
213 | QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems); | |
214 | while (i.hasNext()) { |
|
214 | while (i.hasNext()) { | |
215 | i.next(); |
|
215 | i.next(); | |
216 |
Domain* |
|
216 | Domain *domain = i.value()->domain(); | |
217 |
QAbstractAxis* |
|
217 | QAbstractAxis *axis = i.key(); | |
218 | handleAxisRemoved(axis); |
|
218 | handleAxisRemoved(axis); | |
219 | handleAxisAdded(axis, domain); |
|
219 | handleAxisAdded(axis, domain); | |
220 | } |
|
220 | } | |
221 |
|
221 | |||
222 | QMapIterator<QAbstractSeries*, ChartElement*> j(m_chartItems); |
|
222 | QMapIterator<QAbstractSeries *, ChartElement *> j(m_chartItems); | |
223 | while (j.hasNext()) { |
|
223 | while (j.hasNext()) { | |
224 | j.next(); |
|
224 | j.next(); | |
225 |
Domain* |
|
225 | Domain *domain = j.value()->domain(); | |
226 |
QAbstractSeries* |
|
226 | QAbstractSeries *series = j.key(); | |
227 | handleSeriesRemoved(series); |
|
227 | handleSeriesRemoved(series); | |
228 | handleSeriesAdded(series, domain); |
|
228 | handleSeriesAdded(series, domain); | |
229 | } |
|
229 | } | |
@@ -240,7 +240,7 void ChartPresenter::zoomIn(qreal factor) | |||||
240 | zoomIn(rect); |
|
240 | zoomIn(rect); | |
241 | } |
|
241 | } | |
242 |
|
242 | |||
243 |
void ChartPresenter::zoomIn(const QRectF& |
|
243 | void ChartPresenter::zoomIn(const QRectF &rect) | |
244 | { |
|
244 | { | |
245 | QRectF r = rect.normalized(); |
|
245 | QRectF r = rect.normalized(); | |
246 | r.translate(-chartsGeometry().topLeft()); |
|
246 | r.translate(-chartsGeometry().topLeft()); | |
@@ -306,12 +306,12 void ChartPresenter::createTitleItem() | |||||
306 |
|
306 | |||
307 | void ChartPresenter::handleAnimationFinished() |
|
307 | void ChartPresenter::handleAnimationFinished() | |
308 | { |
|
308 | { | |
309 | m_animations.removeAll(qobject_cast<ChartAnimation*>(sender())); |
|
309 | m_animations.removeAll(qobject_cast<ChartAnimation *>(sender())); | |
310 | if (m_animations.empty()) |
|
310 | if (m_animations.empty()) | |
311 | emit animationsFinished(); |
|
311 | emit animationsFinished(); | |
312 | } |
|
312 | } | |
313 |
|
313 | |||
314 |
void ChartPresenter::startAnimation(ChartAnimation* |
|
314 | void ChartPresenter::startAnimation(ChartAnimation *animation) | |
315 | { |
|
315 | { | |
316 | if (animation->state() != QAbstractAnimation::Stopped) |
|
316 | if (animation->state() != QAbstractAnimation::Stopped) | |
317 | animation->stop(); |
|
317 | animation->stop(); | |
@@ -321,7 +321,7 void ChartPresenter::startAnimation(ChartAnimation* animation) | |||||
321 | QTimer::singleShot(0, animation, SLOT(start())); |
|
321 | QTimer::singleShot(0, animation, SLOT(start())); | |
322 | } |
|
322 | } | |
323 |
|
323 | |||
324 |
void ChartPresenter::setBackgroundBrush(const QBrush& |
|
324 | void ChartPresenter::setBackgroundBrush(const QBrush &brush) | |
325 | { |
|
325 | { | |
326 | createBackgroundItem(); |
|
326 | createBackgroundItem(); | |
327 | m_background->setBrush(brush); |
|
327 | m_background->setBrush(brush); | |
@@ -335,7 +335,7 QBrush ChartPresenter::backgroundBrush() const | |||||
335 | return m_background->brush(); |
|
335 | return m_background->brush(); | |
336 | } |
|
336 | } | |
337 |
|
337 | |||
338 |
void ChartPresenter::setBackgroundPen(const QPen& |
|
338 | void ChartPresenter::setBackgroundPen(const QPen &pen) | |
339 | { |
|
339 | { | |
340 | createBackgroundItem(); |
|
340 | createBackgroundItem(); | |
341 | m_background->setPen(pen); |
|
341 | m_background->setPen(pen); | |
@@ -349,7 +349,7 QPen ChartPresenter::backgroundPen() const | |||||
349 | return m_background->pen(); |
|
349 | return m_background->pen(); | |
350 | } |
|
350 | } | |
351 |
|
351 | |||
352 |
void ChartPresenter::setTitle(const QString& |
|
352 | void ChartPresenter::setTitle(const QString &title) | |
353 | { |
|
353 | { | |
354 | createTitleItem(); |
|
354 | createTitleItem(); | |
355 | m_title->setText(title); |
|
355 | m_title->setText(title); | |
@@ -363,7 +363,7 QString ChartPresenter::title() const | |||||
363 | return m_title->text(); |
|
363 | return m_title->text(); | |
364 | } |
|
364 | } | |
365 |
|
365 | |||
366 |
void ChartPresenter::setTitleFont(const QFont& |
|
366 | void ChartPresenter::setTitleFont(const QFont &font) | |
367 | { |
|
367 | { | |
368 | createTitleItem(); |
|
368 | createTitleItem(); | |
369 | m_title->setFont(font); |
|
369 | m_title->setFont(font); | |
@@ -419,12 +419,12 bool ChartPresenter::isBackgroundDropShadowEnabled() const | |||||
419 | } |
|
419 | } | |
420 |
|
420 | |||
421 |
|
421 | |||
422 |
QGraphicsLayout* |
|
422 | QGraphicsLayout *ChartPresenter::layout() | |
423 | { |
|
423 | { | |
424 | return m_layout; |
|
424 | return m_layout; | |
425 | } |
|
425 | } | |
426 |
|
426 | |||
427 |
void ChartPresenter::setMargins(const QMargins& |
|
427 | void ChartPresenter::setMargins(const QMargins &margins) | |
428 | { |
|
428 | { | |
429 | m_layout->setMargins(margins); |
|
429 | m_layout->setMargins(margins); | |
430 | } |
|
430 | } | |
@@ -434,7 +434,7 QMargins ChartPresenter::margins() const | |||||
434 | return m_layout->margins(); |
|
434 | return m_layout->margins(); | |
435 | } |
|
435 | } | |
436 |
|
436 | |||
437 |
QLegend* |
|
437 | QLegend *ChartPresenter::legend() | |
438 | { |
|
438 | { | |
439 | return m_chart->legend(); |
|
439 | return m_chart->legend(); | |
440 | } |
|
440 | } | |
@@ -444,17 +444,17 void ChartPresenter::setVisible(bool visible) | |||||
444 | m_chart->setVisible(visible); |
|
444 | m_chart->setVisible(visible); | |
445 | } |
|
445 | } | |
446 |
|
446 | |||
447 |
ChartBackground* |
|
447 | ChartBackground *ChartPresenter::backgroundElement() | |
448 | { |
|
448 | { | |
449 | return m_background; |
|
449 | return m_background; | |
450 | } |
|
450 | } | |
451 |
|
451 | |||
452 | QList<ChartAxis*> ChartPresenter::axisItems() const |
|
452 | QList<ChartAxis *> ChartPresenter::axisItems() const | |
453 | { |
|
453 | { | |
454 | return m_axisItems.values(); |
|
454 | return m_axisItems.values(); | |
455 | } |
|
455 | } | |
456 |
|
456 | |||
457 |
ChartTitle* |
|
457 | ChartTitle *ChartPresenter::titleElement() | |
458 | { |
|
458 | { | |
459 | return m_title; |
|
459 | return m_title; | |
460 | } |
|
460 | } |
@@ -78,28 +78,28 public: | |||||
78 | ZoomOutState |
|
78 | ZoomOutState | |
79 | }; |
|
79 | }; | |
80 |
|
80 | |||
81 |
ChartPresenter(QChart* |
|
81 | ChartPresenter(QChart *chart, ChartDataSet *dataset); | |
82 | virtual ~ChartPresenter(); |
|
82 | virtual ~ChartPresenter(); | |
83 |
|
83 | |||
84 | ChartTheme *chartTheme() const { return m_chartTheme; } |
|
84 | ChartTheme *chartTheme() const { return m_chartTheme; } | |
85 | ChartDataSet *dataSet() const { return m_dataset; } |
|
85 | ChartDataSet *dataSet() const { return m_dataset; } | |
86 |
QGraphicsItem* |
|
86 | QGraphicsItem *rootItem() const { return m_chart; } | |
87 |
ChartBackground* |
|
87 | ChartBackground *backgroundElement(); | |
88 |
ChartTitle* |
|
88 | ChartTitle *titleElement(); | |
89 | QList<ChartAxis*> axisItems() const; |
|
89 | QList<ChartAxis *> axisItems() const; | |
90 |
|
90 | |||
91 |
QLegend* |
|
91 | QLegend *legend(); | |
92 |
|
92 | |||
93 |
void setBackgroundBrush(const QBrush& |
|
93 | void setBackgroundBrush(const QBrush &brush); | |
94 | QBrush backgroundBrush() const; |
|
94 | QBrush backgroundBrush() const; | |
95 |
|
95 | |||
96 |
void setBackgroundPen(const QPen& |
|
96 | void setBackgroundPen(const QPen &pen); | |
97 | QPen backgroundPen() const; |
|
97 | QPen backgroundPen() const; | |
98 |
|
98 | |||
99 |
void setTitle(const QString& |
|
99 | void setTitle(const QString &title); | |
100 | QString title() const; |
|
100 | QString title() const; | |
101 |
|
101 | |||
102 |
void setTitleFont(const QFont& |
|
102 | void setTitleFont(const QFont &font); | |
103 | QFont titleFont() const; |
|
103 | QFont titleFont() const; | |
104 |
|
104 | |||
105 | void setTitleBrush(const QBrush &brush); |
|
105 | void setTitleBrush(const QBrush &brush); | |
@@ -120,22 +120,22 public: | |||||
120 | QChart::AnimationOptions animationOptions() const; |
|
120 | QChart::AnimationOptions animationOptions() const; | |
121 |
|
121 | |||
122 | void zoomIn(qreal factor); |
|
122 | void zoomIn(qreal factor); | |
123 |
void zoomIn(const QRectF& |
|
123 | void zoomIn(const QRectF &rect); | |
124 | void zoomOut(qreal factor); |
|
124 | void zoomOut(qreal factor); | |
125 | void scroll(qreal dx, qreal dy); |
|
125 | void scroll(qreal dx, qreal dy); | |
126 |
|
126 | |||
127 |
void setChartsGeometry(const QRectF& |
|
127 | void setChartsGeometry(const QRectF &rect); | |
128 | QRectF chartsGeometry() const; |
|
128 | QRectF chartsGeometry() const; | |
129 |
|
129 | |||
130 |
void startAnimation(ChartAnimation* |
|
130 | void startAnimation(ChartAnimation *animation); | |
131 | State state() const { return m_state; } |
|
131 | State state() const { return m_state; } | |
132 | QPointF statePoint() const { return m_statePoint; } |
|
132 | QPointF statePoint() const { return m_statePoint; } | |
133 |
|
133 | |||
134 | void resetAllElements(); |
|
134 | void resetAllElements(); | |
135 |
|
135 | |||
136 |
void setMargins(const QMargins& |
|
136 | void setMargins(const QMargins &margins); | |
137 | QMargins margins() const; |
|
137 | QMargins margins() const; | |
138 |
QGraphicsLayout* |
|
138 | QGraphicsLayout *layout(); | |
139 |
|
139 | |||
140 | private: |
|
140 | private: | |
141 | void createBackgroundItem(); |
|
141 | void createBackgroundItem(); | |
@@ -143,34 +143,34 private: | |||||
143 | void selectVisibleAxis(); |
|
143 | void selectVisibleAxis(); | |
144 |
|
144 | |||
145 | public Q_SLOTS: |
|
145 | public Q_SLOTS: | |
146 |
void handleSeriesAdded(QAbstractSeries* |
|
146 | void handleSeriesAdded(QAbstractSeries *series, Domain *domain); | |
147 |
void handleSeriesRemoved(QAbstractSeries* |
|
147 | void handleSeriesRemoved(QAbstractSeries *series); | |
148 |
void handleAxisAdded(QAbstractAxis* |
|
148 | void handleAxisAdded(QAbstractAxis *axis, Domain *domain); | |
149 |
void handleAxisRemoved(QAbstractAxis* |
|
149 | void handleAxisRemoved(QAbstractAxis *axis); | |
150 | void handleAxisVisibleChanged(bool visible); |
|
150 | void handleAxisVisibleChanged(bool visible); | |
151 |
|
151 | |||
152 | private Q_SLOTS: |
|
152 | private Q_SLOTS: | |
153 | void handleAnimationFinished(); |
|
153 | void handleAnimationFinished(); | |
154 |
|
154 | |||
155 | Q_SIGNALS: |
|
155 | Q_SIGNALS: | |
156 |
void geometryChanged(const QRectF& |
|
156 | void geometryChanged(const QRectF &rect); | |
157 | void animationsFinished(); |
|
157 | void animationsFinished(); | |
158 | void marginsChanged(QRectF margins); |
|
158 | void marginsChanged(QRectF margins); | |
159 |
|
159 | |||
160 | private: |
|
160 | private: | |
161 |
QChart* |
|
161 | QChart *m_chart; | |
162 |
ChartDataSet* |
|
162 | ChartDataSet *m_dataset; | |
163 | ChartTheme *m_chartTheme; |
|
163 | ChartTheme *m_chartTheme; | |
164 | QMap<QAbstractSeries*, ChartElement*> m_chartItems; |
|
164 | QMap<QAbstractSeries *, ChartElement *> m_chartItems; | |
165 | QMap<QAbstractAxis*, ChartAxis*> m_axisItems; |
|
165 | QMap<QAbstractAxis *, ChartAxis *> m_axisItems; | |
166 | QRectF m_chartsRect; |
|
166 | QRectF m_chartsRect; | |
167 | QChart::AnimationOptions m_options; |
|
167 | QChart::AnimationOptions m_options; | |
168 | State m_state; |
|
168 | State m_state; | |
169 | QPointF m_statePoint; |
|
169 | QPointF m_statePoint; | |
170 | QList<ChartAnimation*> m_animations; |
|
170 | QList<ChartAnimation *> m_animations; | |
171 |
ChartLayout* |
|
171 | ChartLayout *m_layout; | |
172 |
ChartBackground* |
|
172 | ChartBackground *m_background; | |
173 |
ChartTitle* |
|
173 | ChartTitle *m_title; | |
174 | }; |
|
174 | }; | |
175 |
|
175 | |||
176 | QTCOMMERCIALCHART_END_NAMESPACE |
|
176 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -79,7 +79,7 ChartTheme::ChartTheme(QChart::ChartTheme id) : | |||||
79 | } |
|
79 | } | |
80 |
|
80 | |||
81 |
|
81 | |||
82 |
ChartTheme* |
|
82 | ChartTheme *ChartTheme::createTheme(QChart::ChartTheme theme) | |
83 | { |
|
83 | { | |
84 | switch (theme) { |
|
84 | switch (theme) { | |
85 | case QChart::ChartThemeLight: |
|
85 | case QChart::ChartThemeLight: |
@@ -25,7 +25,7 | |||||
25 |
|
25 | |||
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
26 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
27 |
|
27 | |||
28 |
ChartTitle::ChartTitle(QGraphicsItem* |
|
28 | ChartTitle::ChartTitle(QGraphicsItem *parent) | |
29 | : QGraphicsSimpleTextItem(parent) |
|
29 | : QGraphicsSimpleTextItem(parent) | |
30 | { |
|
30 | { | |
31 |
|
31 |
@@ -38,7 +38,7 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
38 | class ChartTitle : public QGraphicsSimpleTextItem |
|
38 | class ChartTitle : public QGraphicsSimpleTextItem | |
39 | { |
|
39 | { | |
40 | public: |
|
40 | public: | |
41 |
ChartTitle(QGraphicsItem* |
|
41 | ChartTitle(QGraphicsItem *parent = 0); | |
42 | ~ChartTitle(); |
|
42 | ~ChartTitle(); | |
43 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const; |
|
43 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const; | |
44 | void setText(const QString &text); |
|
44 | void setText(const QString &text); |
@@ -23,7 +23,7 | |||||
23 |
|
23 | |||
24 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
24 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
25 |
|
25 | |||
26 |
Domain::Domain(QObject* |
|
26 | Domain::Domain(QObject *parent) | |
27 | : QObject(parent), |
|
27 | : QObject(parent), | |
28 | m_minX(0), |
|
28 | m_minX(0), | |
29 | m_maxX(0), |
|
29 | m_maxX(0), | |
@@ -106,7 +106,7 bool Domain::isEmpty() const | |||||
106 | return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY()); |
|
106 | return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY()); | |
107 | } |
|
107 | } | |
108 |
|
108 | |||
109 |
void Domain::zoomIn(const QRectF& |
|
109 | void Domain::zoomIn(const QRectF &rect, const QSizeF &size) | |
110 | { |
|
110 | { | |
111 | qreal dx = spanX() / size.width(); |
|
111 | qreal dx = spanX() / size.width(); | |
112 | qreal dy = spanY() / size.height(); |
|
112 | qreal dy = spanY() / size.height(); | |
@@ -124,7 +124,7 void Domain::zoomIn(const QRectF& rect, const QSizeF& size) | |||||
124 | setRange(minX, maxX, minY, maxY); |
|
124 | setRange(minX, maxX, minY, maxY); | |
125 | } |
|
125 | } | |
126 |
|
126 | |||
127 |
void Domain::zoomOut(const QRectF& |
|
127 | void Domain::zoomOut(const QRectF &rect, const QSizeF &size) | |
128 | { |
|
128 | { | |
129 | qreal dx = spanX() / rect.width(); |
|
129 | qreal dx = spanX() / rect.width(); | |
130 | qreal dy = spanY() / rect.height(); |
|
130 | qreal dy = spanY() / rect.height(); | |
@@ -142,7 +142,7 void Domain::zoomOut(const QRectF& rect, const QSizeF& size) | |||||
142 | setRange(minX, maxX, minY, maxY); |
|
142 | setRange(minX, maxX, minY, maxY); | |
143 | } |
|
143 | } | |
144 |
|
144 | |||
145 |
void Domain::move(qreal dx, qreal dy, const QSizeF& |
|
145 | void Domain::move(qreal dx, qreal dy, const QSizeF &size) | |
146 | { |
|
146 | { | |
147 | qreal x = spanX() / size.width(); |
|
147 | qreal x = spanX() / size.width(); | |
148 | qreal y = spanY() / size.height(); |
|
148 | qreal y = spanY() / size.height(); | |
@@ -170,7 +170,7 void Domain::emitUpdated() | |||||
170 |
|
170 | |||
171 | void Domain::handleAxisUpdated() |
|
171 | void Domain::handleAxisUpdated() | |
172 | { |
|
172 | { | |
173 |
QAbstractAxisPrivate* |
|
173 | QAbstractAxisPrivate *axis = qobject_cast<QAbstractAxisPrivate *>(sender()); | |
174 | Q_ASSERT(axis); |
|
174 | Q_ASSERT(axis); | |
175 | axis->setDirty(false); |
|
175 | axis->setDirty(false); | |
176 | if (axis->orientation() == Qt::Horizontal) |
|
176 | if (axis->orientation() == Qt::Horizontal) |
@@ -40,7 +40,7 class QTCOMMERCIALCHART_AUTOTEST_EXPORT Domain: public QObject | |||||
40 | { |
|
40 | { | |
41 | Q_OBJECT |
|
41 | Q_OBJECT | |
42 | public: |
|
42 | public: | |
43 |
explicit Domain(QObject* |
|
43 | explicit Domain(QObject *object = 0); | |
44 | virtual ~Domain(); |
|
44 | virtual ~Domain(); | |
45 |
|
45 | |||
46 | void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY); |
|
46 | void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY); | |
@@ -64,9 +64,9 public: | |||||
64 | friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2); |
|
64 | friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2); | |
65 | friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain); |
|
65 | friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain); | |
66 |
|
66 | |||
67 |
void zoomIn(const QRectF& |
|
67 | void zoomIn(const QRectF &rect, const QSizeF &size); | |
68 |
void zoomOut(const QRectF& |
|
68 | void zoomOut(const QRectF &rect, const QSizeF &size); | |
69 |
void move(qreal dx, qreal dy, const QSizeF& |
|
69 | void move(qreal dx, qreal dy, const QSizeF &size); | |
70 | void emitUpdated(); |
|
70 | void emitUpdated(); | |
71 |
|
71 | |||
72 | Q_SIGNALS: |
|
72 | Q_SIGNALS: |
@@ -26,7 +26,7 | |||||
26 |
|
26 | |||
27 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
27 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
28 |
|
28 | |||
29 |
LegendLayout::LegendLayout(QLegend* |
|
29 | LegendLayout::LegendLayout(QLegend *legend) | |
30 | : m_legend(legend) |
|
30 | : m_legend(legend) | |
31 | { |
|
31 | { | |
32 |
|
32 | |||
@@ -92,7 +92,7 void LegendLayout::invalidate() | |||||
92 | m_legend->d_ptr->m_presenter->layout()->invalidate(); |
|
92 | m_legend->d_ptr->m_presenter->layout()->invalidate(); | |
93 | } |
|
93 | } | |
94 |
|
94 | |||
95 |
void LegendLayout::setGeometry(const QRectF& |
|
95 | void LegendLayout::setGeometry(const QRectF &rect) | |
96 | { |
|
96 | { | |
97 | m_legend->d_ptr->items()->setVisible(m_legend->isVisible()); |
|
97 | m_legend->d_ptr->items()->setVisible(m_legend->isVisible()); | |
98 |
|
98 | |||
@@ -104,7 +104,7 void LegendLayout::setGeometry(const QRectF& rect) | |||||
104 | setDettachedGeometry(rect); |
|
104 | setDettachedGeometry(rect); | |
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 |
void LegendLayout::setAttachedGeometry(const QRectF& |
|
107 | void LegendLayout::setAttachedGeometry(const QRectF &rect) | |
108 | { |
|
108 | { | |
109 | if (!rect.isValid()) |
|
109 | if (!rect.isValid()) | |
110 | return; |
|
110 | return; | |
@@ -154,7 +154,7 void LegendLayout::setAttachedGeometry(const QRectF& rect) | |||||
154 | if (marker->isVisible()) { |
|
154 | if (marker->isVisible()) { | |
155 | marker->setGeometry(geometry); |
|
155 | marker->setGeometry(geometry); | |
156 | marker->setPos(point); |
|
156 | marker->setPos(point); | |
157 |
const QRectF& |
|
157 | const QRectF &rect = marker->boundingRect(); | |
158 | qreal h = rect.height(); |
|
158 | qreal h = rect.height(); | |
159 | size = size.expandedTo(rect.size()); |
|
159 | size = size.expandedTo(rect.size()); | |
160 | m_height += h; |
|
160 | m_height += h; | |
@@ -177,7 +177,7 void LegendLayout::setAttachedGeometry(const QRectF& rect) | |||||
177 | m_maxOffsetY = m_height - geometry.height() - bottom; |
|
177 | m_maxOffsetY = m_height - geometry.height() - bottom; | |
178 | } |
|
178 | } | |
179 |
|
179 | |||
180 |
void LegendLayout::setDettachedGeometry(const QRectF& |
|
180 | void LegendLayout::setDettachedGeometry(const QRectF &rect) | |
181 | { |
|
181 | { | |
182 | if (!rect.isValid()) |
|
182 | if (!rect.isValid()) | |
183 | return; |
|
183 | return; | |
@@ -211,7 +211,7 void LegendLayout::setDettachedGeometry(const QRectF& rect) | |||||
211 | if (marker->isVisible()) { |
|
211 | if (marker->isVisible()) { | |
212 | marker->setGeometry(geometry); |
|
212 | marker->setGeometry(geometry); | |
213 | marker->setPos(point.x(), point.y()); |
|
213 | marker->setPos(point.x(), point.y()); | |
214 |
const QRectF& |
|
214 | const QRectF &boundingRect = marker->boundingRect(); | |
215 | qreal w = boundingRect.width(); |
|
215 | qreal w = boundingRect.width(); | |
216 | qreal h = boundingRect.height(); |
|
216 | qreal h = boundingRect.height(); | |
217 | m_width = qMax(m_width, w); |
|
217 | m_width = qMax(m_width, w); | |
@@ -277,7 +277,7 void LegendLayout::setDettachedGeometry(const QRectF& rect) | |||||
277 | LegendMarker *marker = markers.at(i); |
|
277 | LegendMarker *marker = markers.at(i); | |
278 | if (marker->isVisible()) { |
|
278 | if (marker->isVisible()) { | |
279 | marker->setGeometry(geometry); |
|
279 | marker->setGeometry(geometry); | |
280 |
const QRectF& |
|
280 | const QRectF &boundingRect = marker->boundingRect(); | |
281 | qreal w = boundingRect.width(); |
|
281 | qreal w = boundingRect.width(); | |
282 | qreal h = boundingRect.height(); |
|
282 | qreal h = boundingRect.height(); | |
283 | m_height = qMax(m_height, h); |
|
283 | m_height = qMax(m_height, h); | |
@@ -313,7 +313,7 void LegendLayout::setDettachedGeometry(const QRectF& rect) | |||||
313 | LegendMarker *marker = markers.at(i); |
|
313 | LegendMarker *marker = markers.at(i); | |
314 | if (marker->isVisible()) { |
|
314 | if (marker->isVisible()) { | |
315 | marker->setGeometry(geometry); |
|
315 | marker->setGeometry(geometry); | |
316 |
const QRectF& |
|
316 | const QRectF &boundingRect = marker->boundingRect(); | |
317 | qreal w = boundingRect.width(); |
|
317 | qreal w = boundingRect.width(); | |
318 | qreal h = boundingRect.height(); |
|
318 | qreal h = boundingRect.height(); | |
319 | m_height = qMax(m_height, h); |
|
319 | m_height = qMax(m_height, h); | |
@@ -346,7 +346,7 void LegendLayout::setDettachedGeometry(const QRectF& rect) | |||||
346 |
|
346 | |||
347 | } |
|
347 | } | |
348 |
|
348 | |||
349 |
QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF & |
|
349 | QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
350 | { |
|
350 | { | |
351 | QSizeF size(0, 0); |
|
351 | QSizeF size(0, 0); | |
352 | qreal left, top, right, bottom; |
|
352 | qreal left, top, right, bottom; |
@@ -31,27 +31,27 class LegendLayout : public QGraphicsLayout | |||||
31 | { |
|
31 | { | |
32 | public: |
|
32 | public: | |
33 |
|
33 | |||
34 |
LegendLayout(QLegend* |
|
34 | LegendLayout(QLegend *legend); | |
35 | virtual ~LegendLayout(); |
|
35 | virtual ~LegendLayout(); | |
36 |
|
36 | |||
37 |
void setGeometry(const QRectF& |
|
37 | void setGeometry(const QRectF &rect); | |
38 |
|
38 | |||
39 | void setOffset(qreal x, qreal y); |
|
39 | void setOffset(qreal x, qreal y); | |
40 | QPointF offset() const; |
|
40 | QPointF offset() const; | |
41 |
|
41 | |||
42 | void invalidate(); |
|
42 | void invalidate(); | |
43 | protected: |
|
43 | protected: | |
44 |
QSizeF sizeHint |
|
44 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const; | |
45 | int count() const { return 0; } |
|
45 | int count() const { return 0; } | |
46 |
QGraphicsLayoutItem* |
|
46 | QGraphicsLayoutItem *itemAt(int) const { return 0; }; | |
47 | void removeAt(int){}; |
|
47 | void removeAt(int) {}; | |
48 |
|
48 | |||
49 | private: |
|
49 | private: | |
50 |
void setAttachedGeometry(const QRectF& |
|
50 | void setAttachedGeometry(const QRectF &rect); | |
51 |
void setDettachedGeometry(const QRectF& |
|
51 | void setDettachedGeometry(const QRectF &rect); | |
52 |
|
52 | |||
53 | private: |
|
53 | private: | |
54 |
QLegend* |
|
54 | QLegend *m_legend; | |
55 | qreal m_offsetX; |
|
55 | qreal m_offsetX; | |
56 | qreal m_offsetY; |
|
56 | qreal m_offsetY; | |
57 | qreal m_minOffsetX; |
|
57 | qreal m_minOffsetX; |
@@ -113,7 +113,7 QBrush LegendMarker::labelBrush() const | |||||
113 | } |
|
113 | } | |
114 |
|
114 | |||
115 |
|
115 | |||
116 |
void LegendMarker::setGeometry(const QRectF& |
|
116 | void LegendMarker::setGeometry(const QRectF &rect) | |
117 | { |
|
117 | { | |
118 | QFontMetrics fn(font()); |
|
118 | QFontMetrics fn(font()); | |
119 |
|
119 | |||
@@ -130,7 +130,7 void LegendMarker::setGeometry(const QRectF& rect) | |||||
130 | m_textItem->setText(m_text); |
|
130 | m_textItem->setText(m_text); | |
131 | } |
|
131 | } | |
132 |
|
132 | |||
133 |
const QRectF& |
|
133 | const QRectF &textRect = m_textItem->boundingRect(); | |
134 | m_textItem->setPos(x - m_margin, y / 2 - textRect.height() / 2); |
|
134 | m_textItem->setPos(x - m_margin, y / 2 - textRect.height() / 2); | |
135 | m_rectItem->setRect(m_markerRect); |
|
135 | m_rectItem->setRect(m_markerRect); | |
136 | m_rectItem->setPos(m_margin, y / 2 - m_markerRect.height() / 2); |
|
136 | m_rectItem->setPos(m_margin, y / 2 - m_markerRect.height() / 2); | |
@@ -146,7 +146,7 void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *opti | |||||
146 | Q_UNUSED(painter) |
|
146 | Q_UNUSED(painter) | |
147 | } |
|
147 | } | |
148 |
|
148 | |||
149 |
QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& |
|
149 | QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const | |
150 | { |
|
150 | { | |
151 | Q_UNUSED(constraint) |
|
151 | Q_UNUSED(constraint) | |
152 |
|
152 | |||
@@ -210,7 +210,7 void BarLegendMarker::updated() | |||||
210 |
|
210 | |||
211 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
211 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
212 |
|
212 | |||
213 |
PieLegendMarker::PieLegendMarker(QPieSeries* |
|
213 | PieLegendMarker::PieLegendMarker(QPieSeries *series, QPieSlice *pieslice, QLegend *legend) | |
214 | : LegendMarker(series, legend), |
|
214 | : LegendMarker(series, legend), | |
215 | m_pieslice(pieslice) |
|
215 | m_pieslice(pieslice) | |
216 | { |
|
216 | { |
@@ -72,13 +72,13 public: | |||||
72 |
|
72 | |||
73 | QAbstractSeries *series() const { return m_series;} |
|
73 | QAbstractSeries *series() const { return m_series;} | |
74 |
|
74 | |||
75 |
void setGeometry(const QRectF& |
|
75 | void setGeometry(const QRectF &rect); | |
76 |
|
76 | |||
77 | QRectF boundingRect() const; |
|
77 | QRectF boundingRect() const; | |
78 |
|
78 | |||
79 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0); |
|
79 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0); | |
80 |
|
80 | |||
81 |
QSizeF sizeHint(Qt::SizeHint which, const QSizeF& |
|
81 | QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const; | |
82 |
|
82 | |||
83 | protected: |
|
83 | protected: | |
84 | // From QGraphicsObject |
|
84 | // From QGraphicsObject | |
@@ -91,7 +91,7 protected: | |||||
91 | QAbstractSeries *m_series; |
|
91 | QAbstractSeries *m_series; | |
92 | QRectF m_markerRect; |
|
92 | QRectF m_markerRect; | |
93 | QRectF m_boundingRect; |
|
93 | QRectF m_boundingRect; | |
94 |
QLegend* |
|
94 | QLegend *m_legend; | |
95 | QGraphicsSimpleTextItem *m_textItem; |
|
95 | QGraphicsSimpleTextItem *m_textItem; | |
96 | QGraphicsRectItem *m_rectItem; |
|
96 | QGraphicsRectItem *m_rectItem; | |
97 | qreal m_margin; |
|
97 | qreal m_margin; |
@@ -43,15 +43,15 class LegendScroller: public QLegend, public Scroller | |||||
43 | public: |
|
43 | public: | |
44 | LegendScroller(QChart *chart): QLegend(chart) { } |
|
44 | LegendScroller(QChart *chart): QLegend(chart) { } | |
45 |
|
45 | |||
46 |
void setOffset(const QPointF& |
|
46 | void setOffset(const QPointF &point) { d_ptr->setOffset(point.x(), point.y()); } | |
47 |
|
47 | |||
48 | QPointF offset() const { return d_ptr->offset(); } |
|
48 | QPointF offset() const { return d_ptr->offset(); } | |
49 |
|
49 | |||
50 |
void mousePressEvent(QGraphicsSceneMouseEvent* |
|
50 | void mousePressEvent(QGraphicsSceneMouseEvent *event) { Scroller::mousePressEvent(event); } | |
51 |
|
51 | |||
52 |
void mouseMoveEvent(QGraphicsSceneMouseEvent* |
|
52 | void mouseMoveEvent(QGraphicsSceneMouseEvent *event) { Scroller::mouseMoveEvent(event); } | |
53 |
|
53 | |||
54 |
void mouseReleaseEvent(QGraphicsSceneMouseEvent* |
|
54 | void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { Scroller::mouseReleaseEvent(event); } | |
55 | }; |
|
55 | }; | |
56 |
|
56 | |||
57 | QTCOMMERCIALCHART_END_NAMESPACE |
|
57 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -416,7 +416,7 void QLegend::showEvent(QShowEvent *event) | |||||
416 |
|
416 | |||
417 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
417 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
418 |
|
418 | |||
419 |
QLegendPrivate::QLegendPrivate(ChartPresenter* |
|
419 | QLegendPrivate::QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q) | |
420 | : q_ptr(q), |
|
420 | : q_ptr(q), | |
421 | m_presenter(presenter), |
|
421 | m_presenter(presenter), | |
422 | m_layout(new LegendLayout(q)), |
|
422 | m_layout(new LegendLayout(q)), | |
@@ -457,7 +457,7 void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain) | |||||
457 | { |
|
457 | { | |
458 | Q_UNUSED(domain) |
|
458 | Q_UNUSED(domain) | |
459 |
|
459 | |||
460 | QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr); |
|
460 | QList<LegendMarker *> markers = series->d_ptr->createLegendMarker(q_ptr); | |
461 |
|
461 | |||
462 | foreach (LegendMarker *marker, markers) { |
|
462 | foreach (LegendMarker *marker, markers) { | |
463 | marker->setFont(m_font); |
|
463 | marker->setFont(m_font); | |
@@ -490,7 +490,7 void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series) | |||||
490 |
|
490 | |||
491 | void QLegendPrivate::handleSeriesVisibleChanged() |
|
491 | void QLegendPrivate::handleSeriesVisibleChanged() | |
492 | { |
|
492 | { | |
493 |
QAbstractSeries* |
|
493 | QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender()); | |
494 | Q_ASSERT(series); |
|
494 | Q_ASSERT(series); | |
495 |
|
495 | |||
496 | foreach (LegendMarker *marker, m_markers) { |
|
496 | foreach (LegendMarker *marker, m_markers) { | |
@@ -502,7 +502,7 void QLegendPrivate::handleSeriesVisibleChanged() | |||||
502 |
|
502 | |||
503 | void QLegendPrivate::handleCountChanged() |
|
503 | void QLegendPrivate::handleCountChanged() | |
504 | { |
|
504 | { | |
505 |
QAbstractSeriesPrivate* |
|
505 | QAbstractSeriesPrivate *series = qobject_cast<QAbstractSeriesPrivate *> (sender()); | |
506 | Q_ASSERT(series); |
|
506 | Q_ASSERT(series); | |
507 | handleSeriesRemoved(series->q_ptr); |
|
507 | handleSeriesRemoved(series->q_ptr); | |
508 | handleSeriesAdded(series->q_ptr, 0); |
|
508 | handleSeriesAdded(series->q_ptr, 0); |
@@ -52,8 +52,8 public: | |||||
52 | QPointF offset() const; |
|
52 | QPointF offset() const; | |
53 | int roundness(qreal size); |
|
53 | int roundness(qreal size); | |
54 |
|
54 | |||
55 | QList<LegendMarker*> markers() { return m_markers; } |
|
55 | QList<LegendMarker *> markers() { return m_markers; } | |
56 |
QGraphicsItemGroup* |
|
56 | QGraphicsItemGroup *items() { return m_items; } | |
57 |
|
57 | |||
58 | public Q_SLOTS: |
|
58 | public Q_SLOTS: | |
59 | void handleSeriesAdded(QAbstractSeries *series, Domain *domain); |
|
59 | void handleSeriesAdded(QAbstractSeries *series, Domain *domain); | |
@@ -65,9 +65,9 private: | |||||
65 | QLegend *q_ptr; |
|
65 | QLegend *q_ptr; | |
66 | ChartPresenter *m_presenter; |
|
66 | ChartPresenter *m_presenter; | |
67 | LegendLayout *m_layout; |
|
67 | LegendLayout *m_layout; | |
68 |
QChart* |
|
68 | QChart *m_chart; | |
69 |
QGraphicsItemGroup* |
|
69 | QGraphicsItemGroup *m_items; | |
70 | QList<LegendMarker*> m_markers; |
|
70 | QList<LegendMarker *> m_markers; | |
71 | Qt::Alignment m_alignment; |
|
71 | Qt::Alignment m_alignment; | |
72 | QBrush m_brush; |
|
72 | QBrush m_brush; | |
73 | QPen m_pen; |
|
73 | QPen m_pen; |
@@ -29,7 +29,7 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
29 |
|
29 | |||
30 | const qreal mouseEventMinWidth(12); |
|
30 | const qreal mouseEventMinWidth(12); | |
31 |
|
31 | |||
32 |
LineChartItem::LineChartItem(QLineSeries* |
|
32 | LineChartItem::LineChartItem(QLineSeries *series, ChartPresenter *presenter) | |
33 | : XYChart(series, presenter), |
|
33 | : XYChart(series, presenter), | |
34 | QGraphicsItem(presenter ? presenter->rootItem() : 0), |
|
34 | QGraphicsItem(presenter ? presenter->rootItem() : 0), | |
35 | m_series(series), |
|
35 | m_series(series), |
@@ -62,7 +62,7 protected: | |||||
62 | void mousePressEvent(QGraphicsSceneMouseEvent *event); |
|
62 | void mousePressEvent(QGraphicsSceneMouseEvent *event); | |
63 |
|
63 | |||
64 | private: |
|
64 | private: | |
65 |
QLineSeries* |
|
65 | QLineSeries *m_series; | |
66 | QPainterPath m_path; |
|
66 | QPainterPath m_path; | |
67 | QPainterPath m_linePath; |
|
67 | QPainterPath m_linePath; | |
68 | QVector<QPointF> m_points; |
|
68 | QVector<QPointF> m_points; |
@@ -142,15 +142,16 QDebug operator<< (QDebug debug, const QLineSeries series) | |||||
142 |
|
142 | |||
143 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
143 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
144 |
|
144 | |||
145 |
QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* |
|
145 | QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries *q) | |
|
146 | : QXYSeriesPrivate(q) | |||
146 | { |
|
147 | { | |
147 |
|
148 | |||
148 | }; |
|
149 | }; | |
149 |
|
150 | |||
150 |
ChartElement* |
|
151 | ChartElement *QLineSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
151 | { |
|
152 | { | |
152 | Q_Q(QLineSeries); |
|
153 | Q_Q(QLineSeries); | |
153 |
LineChartItem* |
|
154 | LineChartItem *line = new LineChartItem(q, presenter); | |
154 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
155 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
155 | line->setAnimation(new XYAnimation(line)); |
|
156 | line->setAnimation(new XYAnimation(line)); | |
156 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
157 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
@@ -38,12 +38,11 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
38 | class QLineSeriesPrivate: public QXYSeriesPrivate |
|
38 | class QLineSeriesPrivate: public QXYSeriesPrivate | |
39 | { |
|
39 | { | |
40 | public: |
|
40 | public: | |
41 |
QLineSeriesPrivate(QLineSeries* |
|
41 | QLineSeriesPrivate(QLineSeries *q); | |
42 |
ChartElement* |
|
42 | ChartElement *createGraphics(ChartPresenter *presenter); | |
43 |
|
43 | |||
44 | private: |
|
44 | private: | |
45 | Q_DECLARE_PUBLIC(QLineSeries); |
|
45 | Q_DECLARE_PUBLIC(QLineSeries); | |
46 |
|
||||
47 | }; |
|
46 | }; | |
48 |
|
47 | |||
49 | QTCOMMERCIALCHART_END_NAMESPACE |
|
48 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -32,7 +32,7 | |||||
32 |
|
32 | |||
33 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
33 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
34 |
|
34 | |||
35 |
PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* |
|
35 | PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter *presenter) | |
36 | : ChartItem(presenter), |
|
36 | : ChartItem(presenter), | |
37 | m_series(series), |
|
37 | m_series(series), | |
38 | m_animation(0) |
|
38 | m_animation(0) | |
@@ -60,17 +60,17 PieChartItem::~PieChartItem() | |||||
60 | // slices deleted automatically through QGraphicsItem |
|
60 | // slices deleted automatically through QGraphicsItem | |
61 | } |
|
61 | } | |
62 |
|
62 | |||
63 |
void PieChartItem::setAnimation(PieAnimation* |
|
63 | void PieChartItem::setAnimation(PieAnimation *animation) | |
64 | { |
|
64 | { | |
65 | m_animation = animation; |
|
65 | m_animation = animation; | |
66 | } |
|
66 | } | |
67 |
|
67 | |||
68 |
ChartAnimation* |
|
68 | ChartAnimation *PieChartItem::animation() const | |
69 | { |
|
69 | { | |
70 | return m_animation; |
|
70 | return m_animation; | |
71 | } |
|
71 | } | |
72 |
|
72 | |||
73 |
void PieChartItem::handleGeometryChanged(const QRectF& |
|
73 | void PieChartItem::handleGeometryChanged(const QRectF &rect) | |
74 | { |
|
74 | { | |
75 | prepareGeometryChange(); |
|
75 | prepareGeometryChange(); | |
76 | m_rect = rect; |
|
76 | m_rect = rect; | |
@@ -143,7 +143,7 void PieChartItem::updateLayout() | |||||
143 | update(); |
|
143 | update(); | |
144 | } |
|
144 | } | |
145 |
|
145 | |||
146 | void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices) |
|
146 | void PieChartItem::handleSlicesAdded(QList<QPieSlice *> slices) | |
147 | { |
|
147 | { | |
148 | // delay creating slice items until there is a proper rectangle |
|
148 | // delay creating slice items until there is a proper rectangle | |
149 | if (!m_rect.isValid() && m_sliceItems.isEmpty()) |
|
149 | if (!m_rect.isValid() && m_sliceItems.isEmpty()) | |
@@ -153,8 +153,8 void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices) | |||||
153 |
|
153 | |||
154 | bool startupAnimation = m_sliceItems.isEmpty(); |
|
154 | bool startupAnimation = m_sliceItems.isEmpty(); | |
155 |
|
155 | |||
156 |
foreach |
|
156 | foreach(QPieSlice * slice, slices) { | |
157 |
PieSliceItem* |
|
157 | PieSliceItem *sliceItem = new PieSliceItem(this); | |
158 | m_sliceItems.insert(slice, sliceItem); |
|
158 | m_sliceItems.insert(slice, sliceItem); | |
159 |
|
159 | |||
160 | // Note: no need to connect to slice valueChanged() etc. |
|
160 | // Note: no need to connect to slice valueChanged() etc. | |
@@ -183,7 +183,7 void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices) | |||||
183 | } |
|
183 | } | |
184 | } |
|
184 | } | |
185 |
|
185 | |||
186 | void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices) |
|
186 | void PieChartItem::handleSlicesRemoved(QList<QPieSlice *> slices) | |
187 | { |
|
187 | { | |
188 | presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series)); |
|
188 | presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series)); | |
189 |
|
189 | |||
@@ -208,9 +208,9 void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices) | |||||
208 |
|
208 | |||
209 | void PieChartItem::handleSliceChanged() |
|
209 | void PieChartItem::handleSliceChanged() | |
210 | { |
|
210 | { | |
211 |
QPieSlice* |
|
211 | QPieSlice *slice = qobject_cast<QPieSlice *>(sender()); | |
212 | if (!slice) { |
|
212 | if (!slice) { | |
213 |
QPieSlicePrivate* |
|
213 | QPieSlicePrivate *slicep = qobject_cast<QPieSlicePrivate *>(sender()); | |
214 | slice = slicep->q_ptr; |
|
214 | slice = slicep->q_ptr; | |
215 | } |
|
215 | } | |
216 | Q_ASSERT(m_sliceItems.contains(slice)); |
|
216 | Q_ASSERT(m_sliceItems.contains(slice)); |
@@ -61,26 +61,26 public Q_SLOTS: | |||||
61 | virtual void rangeYChanged(qreal min, qreal max, int tickYCount); |
|
61 | virtual void rangeYChanged(qreal min, qreal max, int tickYCount); | |
62 |
|
62 | |||
63 | void updateLayout(); |
|
63 | void updateLayout(); | |
64 | void handleSlicesAdded(QList<QPieSlice*> slices); |
|
64 | void handleSlicesAdded(QList<QPieSlice *> slices); | |
65 | void handleSlicesRemoved(QList<QPieSlice*> slices); |
|
65 | void handleSlicesRemoved(QList<QPieSlice *> slices); | |
66 | void handleSliceChanged(); |
|
66 | void handleSliceChanged(); | |
67 | void handleSeriesVisibleChanged(); |
|
67 | void handleSeriesVisibleChanged(); | |
68 | void handleOpacityChanged(); |
|
68 | void handleOpacityChanged(); | |
69 |
|
69 | |||
70 |
void setAnimation(PieAnimation* |
|
70 | void setAnimation(PieAnimation *animation); | |
71 |
ChartAnimation* |
|
71 | ChartAnimation *animation() const; | |
72 |
|
72 | |||
73 | private: |
|
73 | private: | |
74 | PieSliceData updateSliceGeometry(QPieSlice *slice); |
|
74 | PieSliceData updateSliceGeometry(QPieSlice *slice); | |
75 |
|
75 | |||
76 | private: |
|
76 | private: | |
77 | QHash<QPieSlice*, PieSliceItem*> m_sliceItems; |
|
77 | QHash<QPieSlice *, PieSliceItem *> m_sliceItems; | |
78 | QPieSeries *m_series; |
|
78 | QPieSeries *m_series; | |
79 | QRectF m_rect; |
|
79 | QRectF m_rect; | |
80 | QPointF m_pieCenter; |
|
80 | QPointF m_pieCenter; | |
81 | qreal m_pieRadius; |
|
81 | qreal m_pieRadius; | |
82 | qreal m_holeSize; |
|
82 | qreal m_holeSize; | |
83 |
PieAnimation* |
|
83 | PieAnimation *m_animation; | |
84 |
|
84 | |||
85 | }; |
|
85 | }; | |
86 |
|
86 |
@@ -41,7 +41,7 template <class T> | |||||
41 | class Themed : public T |
|
41 | class Themed : public T | |
42 | { |
|
42 | { | |
43 | public: |
|
43 | public: | |
44 | Themed():m_isThemed(true) {} |
|
44 | Themed(): m_isThemed(true) {} | |
45 |
|
45 | |||
46 | inline T &operator=(const T &other) { return T::operator =(other); } |
|
46 | inline T &operator=(const T &other) { return T::operator =(other); } | |
47 |
|
47 | |||
@@ -82,8 +82,7 public: | |||||
82 | { |
|
82 | { | |
83 | } |
|
83 | } | |
84 |
|
84 | |||
85 | bool operator!=(const PieSliceData &other) const |
|
85 | bool operator!=(const PieSliceData &other) const { | |
86 | { |
|
|||
87 | if (!qFuzzyIsNull(m_value - other.m_value)) |
|
86 | if (!qFuzzyIsNull(m_value - other.m_value)) | |
88 | return true; |
|
87 | return true; | |
89 |
|
88 |
@@ -38,7 +38,7 QPointF offset(qreal angle, qreal length) | |||||
38 | return QPointF(dx, -dy); |
|
38 | return QPointF(dx, -dy); | |
39 | } |
|
39 | } | |
40 |
|
40 | |||
41 |
PieSliceItem::PieSliceItem(QGraphicsItem* |
|
41 | PieSliceItem::PieSliceItem(QGraphicsItem *parent) | |
42 | : QGraphicsObject(parent), |
|
42 | : QGraphicsObject(parent), | |
43 | m_hovered(false) |
|
43 | m_hovered(false) | |
44 | { |
|
44 | { | |
@@ -67,7 +67,7 QPainterPath PieSliceItem::shape() const | |||||
67 | return m_slicePath; |
|
67 | return m_slicePath; | |
68 | } |
|
68 | } | |
69 |
|
69 | |||
70 |
void PieSliceItem::paint(QPainter* |
|
70 | void PieSliceItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) | |
71 | { |
|
71 | { | |
72 | painter->save(); |
|
72 | painter->save(); | |
73 | painter->setClipRect(parentItem()->boundingRect()); |
|
73 | painter->setClipRect(parentItem()->boundingRect()); | |
@@ -116,13 +116,13 void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*op | |||||
116 | } |
|
116 | } | |
117 | } |
|
117 | } | |
118 |
|
118 | |||
119 | void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/) |
|
119 | void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/) | |
120 | { |
|
120 | { | |
121 | m_hovered = true; |
|
121 | m_hovered = true; | |
122 | emit hovered(true); |
|
122 | emit hovered(true); | |
123 | } |
|
123 | } | |
124 |
|
124 | |||
125 | void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/) |
|
125 | void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/) | |
126 | { |
|
126 | { | |
127 | m_hovered = false; |
|
127 | m_hovered = false; | |
128 | emit hovered(false); |
|
128 | emit hovered(false); | |
@@ -204,7 +204,7 QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice) | |||||
204 | return point; |
|
204 | return point; | |
205 | } |
|
205 | } | |
206 |
|
206 | |||
207 |
QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF* |
|
207 | QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart) | |
208 | { |
|
208 | { | |
209 | // calculate center angle |
|
209 | // calculate center angle | |
210 | *centerAngle = startAngle + (angleSpan / 2); |
|
210 | *centerAngle = startAngle + (angleSpan / 2); |
@@ -51,7 +51,7 class PieSliceItem : public QGraphicsObject | |||||
51 | Q_OBJECT |
|
51 | Q_OBJECT | |
52 |
|
52 | |||
53 | public: |
|
53 | public: | |
54 |
PieSliceItem(QGraphicsItem* |
|
54 | PieSliceItem(QGraphicsItem *parent = 0); | |
55 | ~PieSliceItem(); |
|
55 | ~PieSliceItem(); | |
56 |
|
56 | |||
57 | // from QGraphicsItem |
|
57 | // from QGraphicsItem |
@@ -160,7 +160,7 QHPieModelMapper::QHPieModelMapper(QObject *parent) : | |||||
160 | setOrientation(Qt::Horizontal); |
|
160 | setOrientation(Qt::Horizontal); | |
161 | } |
|
161 | } | |
162 |
|
162 | |||
163 |
QAbstractItemModel* |
|
163 | QAbstractItemModel *QHPieModelMapper::model() const | |
164 | { |
|
164 | { | |
165 | return QPieModelMapper::model(); |
|
165 | return QPieModelMapper::model(); | |
166 | } |
|
166 | } | |
@@ -173,7 +173,7 void QHPieModelMapper::setModel(QAbstractItemModel *model) | |||||
173 | } |
|
173 | } | |
174 | } |
|
174 | } | |
175 |
|
175 | |||
176 |
QPieSeries* |
|
176 | QPieSeries *QHPieModelMapper::series() const | |
177 | { |
|
177 | { | |
178 | return QPieModelMapper::series(); |
|
178 | return QPieModelMapper::series(); | |
179 | } |
|
179 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QHPieModelMapper : public QPieModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QHPieModelMapper(QObject *parent = 0); |
|
39 | explicit QHPieModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QPieSeries* |
|
44 | QPieSeries *series() const; | |
45 | void setSeries(QPieSeries *series); |
|
45 | void setSeries(QPieSeries *series); | |
46 |
|
46 | |||
47 | int valuesRow() const; |
|
47 | int valuesRow() const; |
@@ -32,7 +32,7 QPieModelMapper::QPieModelMapper(QObject *parent) : | |||||
32 | { |
|
32 | { | |
33 | } |
|
33 | } | |
34 |
|
34 | |||
35 |
QAbstractItemModel* |
|
35 | QAbstractItemModel *QPieModelMapper::model() const | |
36 | { |
|
36 | { | |
37 | Q_D(const QPieModelMapper); |
|
37 | Q_D(const QPieModelMapper); | |
38 | return d->m_model; |
|
38 | return d->m_model; | |
@@ -59,7 +59,7 void QPieModelMapper::setModel(QAbstractItemModel *model) | |||||
59 | connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed())); |
|
59 | connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed())); | |
60 | } |
|
60 | } | |
61 |
|
61 | |||
62 |
QPieSeries* |
|
62 | QPieSeries *QPieModelMapper::series() const | |
63 | { |
|
63 | { | |
64 | Q_D(const QPieModelMapper); |
|
64 | Q_D(const QPieModelMapper); | |
65 | return d->m_series; |
|
65 | return d->m_series; | |
@@ -216,7 +216,7 void QPieModelMapperPrivate::blockSeriesSignals(bool block) | |||||
216 | } |
|
216 | } | |
217 |
|
217 | |||
218 |
|
218 | |||
219 |
QPieSlice* |
|
219 | QPieSlice *QPieModelMapperPrivate::pieSlice(QModelIndex index) const | |
220 | { |
|
220 | { | |
221 | if (!index.isValid()) |
|
221 | if (!index.isValid()) | |
222 | return 0; // index is invalid |
|
222 | return 0; // index is invalid | |
@@ -281,7 +281,7 bool QPieModelMapperPrivate::isValueIndex(QModelIndex index) const | |||||
281 | return false; |
|
281 | return false; | |
282 | } |
|
282 | } | |
283 |
|
283 | |||
284 | void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice*> slices) |
|
284 | void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice *> slices) | |
285 | { |
|
285 | { | |
286 | if (m_seriesSignalsBlock) |
|
286 | if (m_seriesSignalsBlock) | |
287 | return; |
|
287 | return; | |
@@ -315,7 +315,7 void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice*> slices) | |||||
315 | blockModelSignals(false); |
|
315 | blockModelSignals(false); | |
316 | } |
|
316 | } | |
317 |
|
317 | |||
318 | void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice*> slices) |
|
318 | void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice *> slices) | |
319 | { |
|
319 | { | |
320 | if (m_seriesSignalsBlock) |
|
320 | if (m_seriesSignalsBlock) | |
321 | return; |
|
321 | return; |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QPieModelMapper : public QObject | |||||
38 | protected: |
|
38 | protected: | |
39 | explicit QPieModelMapper(QObject *parent = 0); |
|
39 | explicit QPieModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QPieSeries* |
|
44 | QPieSeries *series() const; | |
45 | void setSeries(QPieSeries *series); |
|
45 | void setSeries(QPieSeries *series); | |
46 |
|
46 | |||
47 | int first() const; |
|
47 | int first() const; |
@@ -56,8 +56,8 public Q_SLOTS: | |||||
56 | void handleModelDestroyed(); |
|
56 | void handleModelDestroyed(); | |
57 |
|
57 | |||
58 | // for the series |
|
58 | // for the series | |
59 | void slicesAdded(QList<QPieSlice*> slices); |
|
59 | void slicesAdded(QList<QPieSlice *> slices); | |
60 | void slicesRemoved(QList<QPieSlice*> slices); |
|
60 | void slicesRemoved(QList<QPieSlice *> slices); | |
61 | void sliceLabelChanged(); |
|
61 | void sliceLabelChanged(); | |
62 | void sliceValueChanged(); |
|
62 | void sliceValueChanged(); | |
63 | void handleSeriesDestroyed(); |
|
63 | void handleSeriesDestroyed(); | |
@@ -65,7 +65,7 public Q_SLOTS: | |||||
65 | void initializePieFromModel(); |
|
65 | void initializePieFromModel(); | |
66 |
|
66 | |||
67 | private: |
|
67 | private: | |
68 |
QPieSlice* |
|
68 | QPieSlice *pieSlice(QModelIndex index) const; | |
69 | bool isLabelIndex(QModelIndex index) const; |
|
69 | bool isLabelIndex(QModelIndex index) const; | |
70 | bool isValueIndex(QModelIndex index) const; |
|
70 | bool isValueIndex(QModelIndex index) const; | |
71 | QModelIndex valueModelIndex(int slicePos); |
|
71 | QModelIndex valueModelIndex(int slicePos); | |
@@ -78,7 +78,7 private: | |||||
78 |
|
78 | |||
79 | private: |
|
79 | private: | |
80 | QPieSeries *m_series; |
|
80 | QPieSeries *m_series; | |
81 | QList<QPieSlice*> m_slices; |
|
81 | QList<QPieSlice *> m_slices; | |
82 | QAbstractItemModel *m_model; |
|
82 | QAbstractItemModel *m_model; | |
83 | int m_first; |
|
83 | int m_first; | |
84 | int m_count; |
|
84 | int m_count; |
@@ -376,9 +376,9 QAbstractSeries::SeriesType QPieSeries::type() const | |||||
376 |
|
376 | |||
377 | Returns true if append was succesfull. |
|
377 | Returns true if append was succesfull. | |
378 | */ |
|
378 | */ | |
379 |
bool QPieSeries::append(QPieSlice* |
|
379 | bool QPieSeries::append(QPieSlice *slice) | |
380 | { |
|
380 | { | |
381 | return append(QList<QPieSlice*>() << slice); |
|
381 | return append(QList<QPieSlice *>() << slice); | |
382 | } |
|
382 | } | |
383 |
|
383 | |||
384 | /*! |
|
384 | /*! | |
@@ -387,7 +387,7 bool QPieSeries::append(QPieSlice* slice) | |||||
387 |
|
387 | |||
388 | Returns true if append was successful. |
|
388 | Returns true if append was successful. | |
389 | */ |
|
389 | */ | |
390 | bool QPieSeries::append(QList<QPieSlice*> slices) |
|
390 | bool QPieSeries::append(QList<QPieSlice *> slices) | |
391 | { |
|
391 | { | |
392 | Q_D(QPieSeries); |
|
392 | Q_D(QPieSeries); | |
393 |
|
393 | |||
@@ -425,7 +425,7 bool QPieSeries::append(QList<QPieSlice*> slices) | |||||
425 | Appends a single \a slice to the series and returns a reference to the series. |
|
425 | Appends a single \a slice to the series and returns a reference to the series. | |
426 | Slice ownership is passed to the series. |
|
426 | Slice ownership is passed to the series. | |
427 | */ |
|
427 | */ | |
428 |
QPieSeries& |
|
428 | QPieSeries &QPieSeries::operator << (QPieSlice *slice) | |
429 | { |
|
429 | { | |
430 | append(slice); |
|
430 | append(slice); | |
431 | return *this; |
|
431 | return *this; | |
@@ -436,9 +436,9 QPieSeries& QPieSeries::operator << (QPieSlice* slice) | |||||
436 | Appends a single slice to the series with give \a value and \a label. |
|
436 | Appends a single slice to the series with give \a value and \a label. | |
437 | Slice ownership is passed to the series. |
|
437 | Slice ownership is passed to the series. | |
438 | */ |
|
438 | */ | |
439 |
QPieSlice* |
|
439 | QPieSlice *QPieSeries::append(QString label, qreal value) | |
440 | { |
|
440 | { | |
441 |
QPieSlice* |
|
441 | QPieSlice *slice = new QPieSlice(label, value); | |
442 | append(slice); |
|
442 | append(slice); | |
443 | return slice; |
|
443 | return slice; | |
444 | } |
|
444 | } | |
@@ -449,7 +449,7 QPieSlice* QPieSeries::append(QString label, qreal value) | |||||
449 |
|
449 | |||
450 | Returns true if insert was successful. |
|
450 | Returns true if insert was successful. | |
451 | */ |
|
451 | */ | |
452 |
bool QPieSeries::insert(int index, QPieSlice* |
|
452 | bool QPieSeries::insert(int index, QPieSlice *slice) | |
453 | { |
|
453 | { | |
454 | Q_D(QPieSeries); |
|
454 | Q_D(QPieSeries); | |
455 |
|
455 | |||
@@ -473,7 +473,7 bool QPieSeries::insert(int index, QPieSlice* slice) | |||||
473 | connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool))); |
|
473 | connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool))); | |
474 |
|
474 | |||
475 |
|
475 | |||
476 | emit added(QList<QPieSlice*>() << slice); |
|
476 | emit added(QList<QPieSlice *>() << slice); | |
477 | emit countChanged(); |
|
477 | emit countChanged(); | |
478 |
|
478 | |||
479 | return true; |
|
479 | return true; | |
@@ -486,7 +486,7 bool QPieSeries::insert(int index, QPieSlice* slice) | |||||
486 |
|
486 | |||
487 | Returns true if remove was successful. |
|
487 | Returns true if remove was successful. | |
488 | */ |
|
488 | */ | |
489 |
bool QPieSeries::remove(QPieSlice* |
|
489 | bool QPieSeries::remove(QPieSlice *slice) | |
490 | { |
|
490 | { | |
491 | Q_D(QPieSeries); |
|
491 | Q_D(QPieSeries); | |
492 |
|
492 | |||
@@ -495,7 +495,7 bool QPieSeries::remove(QPieSlice* slice) | |||||
495 |
|
495 | |||
496 | d->updateDerivativeData(); |
|
496 | d->updateDerivativeData(); | |
497 |
|
497 | |||
498 | emit removed(QList<QPieSlice*>() << slice); |
|
498 | emit removed(QList<QPieSlice *>() << slice); | |
499 | emit countChanged(); |
|
499 | emit countChanged(); | |
500 |
|
500 | |||
501 | delete slice; |
|
501 | delete slice; | |
@@ -512,7 +512,7 bool QPieSeries::remove(QPieSlice* slice) | |||||
512 |
|
512 | |||
513 | Returns true if take was successful. |
|
513 | Returns true if take was successful. | |
514 | */ |
|
514 | */ | |
515 |
bool QPieSeries::take(QPieSlice* |
|
515 | bool QPieSeries::take(QPieSlice *slice) | |
516 | { |
|
516 | { | |
517 | Q_D(QPieSeries); |
|
517 | Q_D(QPieSeries); | |
518 |
|
518 | |||
@@ -524,7 +524,7 bool QPieSeries::take(QPieSlice* slice) | |||||
524 |
|
524 | |||
525 | d->updateDerivativeData(); |
|
525 | d->updateDerivativeData(); | |
526 |
|
526 | |||
527 | emit removed(QList<QPieSlice*>() << slice); |
|
527 | emit removed(QList<QPieSlice *>() << slice); | |
528 | emit countChanged(); |
|
528 | emit countChanged(); | |
529 |
|
529 | |||
530 | return true; |
|
530 | return true; | |
@@ -539,7 +539,7 void QPieSeries::clear() | |||||
539 | if (d->m_slices.count() == 0) |
|
539 | if (d->m_slices.count() == 0) | |
540 | return; |
|
540 | return; | |
541 |
|
541 | |||
542 | QList<QPieSlice*> slices = d->m_slices; |
|
542 | QList<QPieSlice *> slices = d->m_slices; | |
543 | foreach (QPieSlice *s, d->m_slices) |
|
543 | foreach (QPieSlice *s, d->m_slices) | |
544 | d->m_slices.removeOne(s); |
|
544 | d->m_slices.removeOne(s); | |
545 |
|
545 | |||
@@ -555,7 +555,7 void QPieSeries::clear() | |||||
555 | /*! |
|
555 | /*! | |
556 | Returns a list of slices that belong to this series. |
|
556 | Returns a list of slices that belong to this series. | |
557 | */ |
|
557 | */ | |
558 | QList<QPieSlice*> QPieSeries::slices() const |
|
558 | QList<QPieSlice *> QPieSeries::slices() const | |
559 | { |
|
559 | { | |
560 | Q_D(const QPieSeries); |
|
560 | Q_D(const QPieSeries); | |
561 | return d->m_slices; |
|
561 | return d->m_slices; | |
@@ -776,7 +776,7 void QPieSeriesPrivate::updateDerivativeData() | |||||
776 | // update slice attributes |
|
776 | // update slice attributes | |
777 | qreal sliceAngle = m_pieStartAngle; |
|
777 | qreal sliceAngle = m_pieStartAngle; | |
778 | qreal pieSpan = m_pieEndAngle - m_pieStartAngle; |
|
778 | qreal pieSpan = m_pieEndAngle - m_pieStartAngle; | |
779 | QVector<QPieSlice*> changed; |
|
779 | QVector<QPieSlice *> changed; | |
780 | foreach (QPieSlice *s, m_slices) { |
|
780 | foreach (QPieSlice *s, m_slices) { | |
781 | QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s); |
|
781 | QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s); | |
782 | d->setPercentage(s->value() / m_sum); |
|
782 | d->setPercentage(s->value() / m_sum); | |
@@ -807,7 +807,7 void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize) | |||||
807 | emit pieSizeChanged(); |
|
807 | emit pieSizeChanged(); | |
808 | } |
|
808 | } | |
809 |
|
809 | |||
810 |
QPieSeriesPrivate* |
|
810 | QPieSeriesPrivate *QPieSeriesPrivate::fromSeries(QPieSeries *series) | |
811 | { |
|
811 | { | |
812 | return series->d_func(); |
|
812 | return series->d_func(); | |
813 | } |
|
813 | } | |
@@ -820,7 +820,7 void QPieSeriesPrivate::sliceValueChanged() | |||||
820 |
|
820 | |||
821 | void QPieSeriesPrivate::sliceClicked() |
|
821 | void QPieSeriesPrivate::sliceClicked() | |
822 | { |
|
822 | { | |
823 |
QPieSlice* |
|
823 | QPieSlice *slice = qobject_cast<QPieSlice *>(sender()); | |
824 | Q_ASSERT(m_slices.contains(slice)); |
|
824 | Q_ASSERT(m_slices.contains(slice)); | |
825 | Q_Q(QPieSeries); |
|
825 | Q_Q(QPieSeries); | |
826 | emit q->clicked(slice); |
|
826 | emit q->clicked(slice); | |
@@ -828,32 +828,32 void QPieSeriesPrivate::sliceClicked() | |||||
828 |
|
828 | |||
829 | void QPieSeriesPrivate::sliceHovered(bool state) |
|
829 | void QPieSeriesPrivate::sliceHovered(bool state) | |
830 | { |
|
830 | { | |
831 |
QPieSlice* |
|
831 | QPieSlice *slice = qobject_cast<QPieSlice *>(sender()); | |
832 | Q_ASSERT(m_slices.contains(slice)); |
|
832 | Q_ASSERT(m_slices.contains(slice)); | |
833 | Q_Q(QPieSeries); |
|
833 | Q_Q(QPieSeries); | |
834 | emit q->hovered(slice, state); |
|
834 | emit q->hovered(slice, state); | |
835 | } |
|
835 | } | |
836 |
|
836 | |||
837 |
void QPieSeriesPrivate::scaleDomain(Domain& |
|
837 | void QPieSeriesPrivate::scaleDomain(Domain &domain) | |
838 | { |
|
838 | { | |
839 | Q_UNUSED(domain); |
|
839 | Q_UNUSED(domain); | |
840 | // does not apply to pie |
|
840 | // does not apply to pie | |
841 | } |
|
841 | } | |
842 |
|
842 | |||
843 |
ChartElement* |
|
843 | ChartElement *QPieSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
844 | { |
|
844 | { | |
845 | Q_Q(QPieSeries); |
|
845 | Q_Q(QPieSeries); | |
846 |
PieChartItem* |
|
846 | PieChartItem *pie = new PieChartItem(q, presenter); | |
847 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) |
|
847 | if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) | |
848 | pie->setAnimation(new PieAnimation(pie)); |
|
848 | pie->setAnimation(new PieAnimation(pie)); | |
849 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); |
|
849 | presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q)); | |
850 | return pie; |
|
850 | return pie; | |
851 | } |
|
851 | } | |
852 |
|
852 | |||
853 |
QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* |
|
853 | QList<LegendMarker *> QPieSeriesPrivate::createLegendMarker(QLegend *legend) | |
854 | { |
|
854 | { | |
855 | Q_Q(QPieSeries); |
|
855 | Q_Q(QPieSeries); | |
856 | QList<LegendMarker*> markers; |
|
856 | QList<LegendMarker *> markers; | |
857 | foreach (QPieSlice *slice, q->slices()) { |
|
857 | foreach (QPieSlice *slice, q->slices()) { | |
858 | PieLegendMarker* marker = new PieLegendMarker(q, slice, legend); |
|
858 | PieLegendMarker* marker = new PieLegendMarker(q, slice, legend); | |
859 | markers << marker; |
|
859 | markers << marker; | |
@@ -861,7 +861,7 QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend) | |||||
861 | return markers; |
|
861 | return markers; | |
862 | } |
|
862 | } | |
863 |
|
863 | |||
864 |
void QPieSeriesPrivate::initializeAxis(QAbstractAxis* |
|
864 | void QPieSeriesPrivate::initializeAxis(QAbstractAxis *axis) | |
865 | { |
|
865 | { | |
866 | Q_UNUSED(axis); |
|
866 | Q_UNUSED(axis); | |
867 | } |
|
867 | } |
@@ -45,18 +45,18 public: | |||||
45 |
|
45 | |||
46 | QAbstractSeries::SeriesType type() const; |
|
46 | QAbstractSeries::SeriesType type() const; | |
47 |
|
47 | |||
48 |
bool append(QPieSlice* |
|
48 | bool append(QPieSlice *slice); | |
49 | bool append(QList<QPieSlice*> slices); |
|
49 | bool append(QList<QPieSlice *> slices); | |
50 |
QPieSeries& |
|
50 | QPieSeries &operator << (QPieSlice *slice); | |
51 |
QPieSlice* |
|
51 | QPieSlice *append(QString label, qreal value); | |
52 |
|
52 | |||
53 |
bool insert(int index, QPieSlice* |
|
53 | bool insert(int index, QPieSlice *slice); | |
54 |
|
54 | |||
55 |
bool remove(QPieSlice* |
|
55 | bool remove(QPieSlice *slice); | |
56 |
bool take(QPieSlice* |
|
56 | bool take(QPieSlice *slice); | |
57 | void clear(); |
|
57 | void clear(); | |
58 |
|
58 | |||
59 | QList<QPieSlice*> slices() const; |
|
59 | QList<QPieSlice *> slices() const; | |
60 | int count() const; |
|
60 | int count() const; | |
61 |
|
61 | |||
62 | bool isEmpty() const; |
|
62 | bool isEmpty() const; | |
@@ -85,10 +85,10 public: | |||||
85 | void setLabelsPosition(QPieSlice::LabelPosition position); |
|
85 | void setLabelsPosition(QPieSlice::LabelPosition position); | |
86 |
|
86 | |||
87 | Q_SIGNALS: |
|
87 | Q_SIGNALS: | |
88 | void added(QList<QPieSlice*> slices); |
|
88 | void added(QList<QPieSlice *> slices); | |
89 | void removed(QList<QPieSlice*> slices); |
|
89 | void removed(QList<QPieSlice *> slices); | |
90 |
void clicked(QPieSlice* |
|
90 | void clicked(QPieSlice *slice); | |
91 |
void hovered(QPieSlice* |
|
91 | void hovered(QPieSlice *slice, bool state); | |
92 | void countChanged(); |
|
92 | void countChanged(); | |
93 | void sumChanged(); |
|
93 | void sumChanged(); | |
94 |
|
94 |
@@ -44,16 +44,16 public: | |||||
44 | QPieSeriesPrivate(QPieSeries *parent); |
|
44 | QPieSeriesPrivate(QPieSeries *parent); | |
45 | ~QPieSeriesPrivate(); |
|
45 | ~QPieSeriesPrivate(); | |
46 |
|
46 | |||
47 |
void scaleDomain(Domain& |
|
47 | void scaleDomain(Domain &domain); | |
48 |
ChartElement* |
|
48 | ChartElement *createGraphics(ChartPresenter *presenter); | |
49 | QList<LegendMarker*> createLegendMarker(QLegend *legend); |
|
49 | QList<LegendMarker *> createLegendMarker(QLegend *legend); | |
50 |
void initializeAxis(QAbstractAxis* |
|
50 | void initializeAxis(QAbstractAxis *axis); | |
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; |
|
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
52 |
|
52 | |||
53 | void updateDerivativeData(); |
|
53 | void updateDerivativeData(); | |
54 | void setSizes(qreal innerSize, qreal outerSize); |
|
54 | void setSizes(qreal innerSize, qreal outerSize); | |
55 |
|
55 | |||
56 |
static QPieSeriesPrivate* |
|
56 | static QPieSeriesPrivate *fromSeries(QPieSeries *series); | |
57 |
|
57 | |||
58 | signals: |
|
58 | signals: | |
59 | void calculatedDataChanged(); |
|
59 | void calculatedDataChanged(); | |
@@ -69,7 +69,7 public Q_SLOTS: | |||||
69 | void sliceHovered(bool state); |
|
69 | void sliceHovered(bool state); | |
70 |
|
70 | |||
71 | private: |
|
71 | private: | |
72 | QList<QPieSlice*> m_slices; |
|
72 | QList<QPieSlice *> m_slices; | |
73 | qreal m_pieRelativeHorPos; |
|
73 | qreal m_pieRelativeHorPos; | |
74 | qreal m_pieRelativeVerPos; |
|
74 | qreal m_pieRelativeVerPos; | |
75 | qreal m_pieRelativeSize; |
|
75 | qreal m_pieRelativeSize; |
@@ -45,7 +45,7 public: | |||||
45 | QPieSlicePrivate(QPieSlice *parent); |
|
45 | QPieSlicePrivate(QPieSlice *parent); | |
46 | ~QPieSlicePrivate(); |
|
46 | ~QPieSlicePrivate(); | |
47 |
|
47 | |||
48 |
static QPieSlicePrivate* |
|
48 | static QPieSlicePrivate *fromSlice(QPieSlice *slice); | |
49 |
|
49 | |||
50 | void setPen(const QPen &pen, bool themed); |
|
50 | void setPen(const QPen &pen, bool themed); | |
51 | void setBrush(const QBrush &brush, bool themed); |
|
51 | void setBrush(const QBrush &brush, bool themed); |
@@ -163,7 +163,7 QVPieModelMapper::QVPieModelMapper(QObject *parent) : | |||||
163 | QPieModelMapper::setOrientation(Qt::Vertical); |
|
163 | QPieModelMapper::setOrientation(Qt::Vertical); | |
164 | } |
|
164 | } | |
165 |
|
165 | |||
166 |
QAbstractItemModel* |
|
166 | QAbstractItemModel *QVPieModelMapper::model() const | |
167 | { |
|
167 | { | |
168 | return QPieModelMapper::model(); |
|
168 | return QPieModelMapper::model(); | |
169 | } |
|
169 | } | |
@@ -176,7 +176,7 void QVPieModelMapper::setModel(QAbstractItemModel *model) | |||||
176 | } |
|
176 | } | |
177 | } |
|
177 | } | |
178 |
|
178 | |||
179 |
QPieSeries* |
|
179 | QPieSeries *QVPieModelMapper::series() const | |
180 | { |
|
180 | { | |
181 | return QPieModelMapper::series(); |
|
181 | return QPieModelMapper::series(); | |
182 | } |
|
182 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QVPieModelMapper : public QPieModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QVPieModelMapper(QObject *parent = 0); |
|
39 | explicit QVPieModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QPieSeries* |
|
44 | QPieSeries *series() const; | |
45 | void setSeries(QPieSeries *series); |
|
45 | void setSeries(QPieSeries *series); | |
46 |
|
46 | |||
47 | int valuesColumn() const; |
|
47 | int valuesColumn() const; |
@@ -141,7 +141,7 QAbstractSeries::~QAbstractSeries() | |||||
141 | qFatal("Still binded series detected !"); |
|
141 | qFatal("Still binded series detected !"); | |
142 | } |
|
142 | } | |
143 |
|
143 | |||
144 |
void QAbstractSeries::setName(const QString& |
|
144 | void QAbstractSeries::setName(const QString &name) | |
145 | { |
|
145 | { | |
146 | if (name != d_ptr->m_name) { |
|
146 | if (name != d_ptr->m_name) { | |
147 | d_ptr->m_name = name; |
|
147 | d_ptr->m_name = name; | |
@@ -192,7 +192,7 void QAbstractSeries::setOpacity(qreal opacity) | |||||
192 | Set automatically when the series is added to the chart |
|
192 | Set automatically when the series is added to the chart | |
193 | and unset when the series is removed from the chart. |
|
193 | and unset when the series is removed from the chart. | |
194 | */ |
|
194 | */ | |
195 |
QChart* |
|
195 | QChart *QAbstractSeries::chart() const | |
196 | { |
|
196 | { | |
197 | return d_ptr->m_chart; |
|
197 | return d_ptr->m_chart; | |
198 | } |
|
198 | } | |
@@ -224,7 +224,7 void QAbstractSeries::hide() | |||||
224 |
|
224 | |||
225 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
|
225 | /////////////////////////////////////////////////////////////////////////////////////////////////// | |
226 |
|
226 | |||
227 |
QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* |
|
227 | QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q) | |
228 | : q_ptr(q), |
|
228 | : q_ptr(q), | |
229 | m_chart(0), |
|
229 | m_chart(0), | |
230 | m_dataset(0), |
|
230 | m_dataset(0), |
@@ -62,14 +62,14 public: | |||||
62 | ~QAbstractSeries(); |
|
62 | ~QAbstractSeries(); | |
63 | virtual SeriesType type() const = 0; |
|
63 | virtual SeriesType type() const = 0; | |
64 |
|
64 | |||
65 |
void setName(const QString& |
|
65 | void setName(const QString &name); | |
66 | QString name() const; |
|
66 | QString name() const; | |
67 | void setVisible(bool visible = true); |
|
67 | void setVisible(bool visible = true); | |
68 | bool isVisible() const; |
|
68 | bool isVisible() const; | |
69 | qreal opacity() const; |
|
69 | qreal opacity() const; | |
70 | void setOpacity(qreal opacity); |
|
70 | void setOpacity(qreal opacity); | |
71 |
|
71 | |||
72 |
QChart* |
|
72 | QChart *chart() const; | |
73 |
|
73 | |||
74 | void show(); |
|
74 | void show(); | |
75 | void hide(); |
|
75 | void hide(); |
@@ -49,10 +49,10 public: | |||||
49 | QAbstractSeriesPrivate(QAbstractSeries *q); |
|
49 | QAbstractSeriesPrivate(QAbstractSeries *q); | |
50 | ~QAbstractSeriesPrivate(); |
|
50 | ~QAbstractSeriesPrivate(); | |
51 |
|
51 | |||
52 |
virtual void scaleDomain(Domain& |
|
52 | virtual void scaleDomain(Domain &domain) = 0; | |
53 |
virtual ChartElement* |
|
53 | virtual ChartElement *createGraphics(ChartPresenter *presenter) = 0; | |
54 |
virtual QList<LegendMarker*> createLegendMarker(QLegend* |
|
54 | virtual QList<LegendMarker *> createLegendMarker(QLegend *legend) = 0; | |
55 |
virtual void initializeAxis(QAbstractAxis* |
|
55 | virtual void initializeAxis(QAbstractAxis *axis) = 0; | |
56 | virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0; |
|
56 | virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0; | |
57 |
|
57 | |||
58 | Q_SIGNALS: |
|
58 | Q_SIGNALS: |
@@ -166,7 +166,7 void QChart::removeAllSeries() | |||||
166 | /*! |
|
166 | /*! | |
167 | Sets the \a brush that is used for painting the background of the chart area. |
|
167 | Sets the \a brush that is used for painting the background of the chart area. | |
168 | */ |
|
168 | */ | |
169 |
void QChart::setBackgroundBrush(const QBrush& |
|
169 | void QChart::setBackgroundBrush(const QBrush &brush) | |
170 | { |
|
170 | { | |
171 | d_ptr->m_presenter->setBackgroundBrush(brush); |
|
171 | d_ptr->m_presenter->setBackgroundBrush(brush); | |
172 | } |
|
172 | } | |
@@ -182,7 +182,7 QBrush QChart::backgroundBrush() const | |||||
182 | /*! |
|
182 | /*! | |
183 | Sets the \a pen that is used for painting the background of the chart area. |
|
183 | Sets the \a pen that is used for painting the background of the chart area. | |
184 | */ |
|
184 | */ | |
185 |
void QChart::setBackgroundPen(const QPen& |
|
185 | void QChart::setBackgroundPen(const QPen &pen) | |
186 | { |
|
186 | { | |
187 | d_ptr->m_presenter->setBackgroundPen(pen); |
|
187 | d_ptr->m_presenter->setBackgroundPen(pen); | |
188 | } |
|
188 | } | |
@@ -198,7 +198,7 QPen QChart::backgroundPen() const | |||||
198 | /*! |
|
198 | /*! | |
199 | Sets the chart \a title. The description text that is drawn above the chart. |
|
199 | Sets the chart \a title. The description text that is drawn above the chart. | |
200 | */ |
|
200 | */ | |
201 |
void QChart::setTitle(const QString& |
|
201 | void QChart::setTitle(const QString &title) | |
202 | { |
|
202 | { | |
203 | d_ptr->m_presenter->setTitle(title); |
|
203 | d_ptr->m_presenter->setTitle(title); | |
204 | } |
|
204 | } | |
@@ -214,7 +214,7 QString QChart::title() const | |||||
214 | /*! |
|
214 | /*! | |
215 | Sets the \a font that is used for drawing the chart description text that is rendered above the chart. |
|
215 | Sets the \a font that is used for drawing the chart description text that is rendered above the chart. | |
216 | */ |
|
216 | */ | |
217 |
void QChart::setTitleFont(const QFont& |
|
217 | void QChart::setTitleFont(const QFont &font) | |
218 | { |
|
218 | { | |
219 | d_ptr->m_presenter->setTitleFont(font); |
|
219 | d_ptr->m_presenter->setTitleFont(font); | |
220 | } |
|
220 | } | |
@@ -264,9 +264,10 void QChart::zoomIn() | |||||
264 | /*! |
|
264 | /*! | |
265 | Zooms in the view to a maximum level at which \a rect is still fully visible. |
|
265 | Zooms in the view to a maximum level at which \a rect is still fully visible. | |
266 | */ |
|
266 | */ | |
267 |
void QChart::zoomIn(const QRectF& |
|
267 | void QChart::zoomIn(const QRectF &rect) | |
268 | { |
|
268 | { | |
269 |
if (!rect.isValid()) |
|
269 | if (!rect.isValid()) | |
|
270 | return; | |||
270 | d_ptr->m_presenter->zoomIn(rect); |
|
271 | d_ptr->m_presenter->zoomIn(rect); | |
271 | } |
|
272 | } | |
272 |
|
273 | |||
@@ -304,7 +305,7 void QChart::zoom(qreal factor) | |||||
304 | Returns the pointer to the x axis object of the chart asociated with the specified \a series |
|
305 | Returns the pointer to the x axis object of the chart asociated with the specified \a series | |
305 | If no series is provided then pointer to currently visible axis is provided |
|
306 | If no series is provided then pointer to currently visible axis is provided | |
306 | */ |
|
307 | */ | |
307 |
QAbstractAxis* |
|
308 | QAbstractAxis *QChart::axisX(QAbstractSeries *series) const | |
308 | { |
|
309 | { | |
309 | return d_ptr->m_dataset->axisX(series); |
|
310 | return d_ptr->m_dataset->axisX(series); | |
310 | } |
|
311 | } | |
@@ -313,7 +314,7 QAbstractAxis* QChart::axisX(QAbstractSeries* series) const | |||||
313 | Returns the pointer to the y axis object of the chart asociated with the specified \a series |
|
314 | Returns the pointer to the y axis object of the chart asociated with the specified \a series | |
314 | If no series is provided then pointer to currently visible axis is provided |
|
315 | If no series is provided then pointer to currently visible axis is provided | |
315 | */ |
|
316 | */ | |
316 |
QAbstractAxis* |
|
317 | QAbstractAxis *QChart::axisY(QAbstractSeries *series) const | |
317 | { |
|
318 | { | |
318 | return d_ptr->m_dataset->axisY(series); |
|
319 | return d_ptr->m_dataset->axisY(series); | |
319 | } |
|
320 | } | |
@@ -360,7 +361,7 void QChart::createDefaultAxes() | |||||
360 | /*! |
|
361 | /*! | |
361 | Returns the legend object of the chart. Ownership stays in chart. |
|
362 | Returns the legend object of the chart. Ownership stays in chart. | |
362 | */ |
|
363 | */ | |
363 |
QLegend* |
|
364 | QLegend *QChart::legend() const | |
364 | { |
|
365 | { | |
365 | return d_ptr->m_legend; |
|
366 | return d_ptr->m_legend; | |
366 | } |
|
367 | } | |
@@ -368,7 +369,7 QLegend* QChart::legend() const | |||||
368 | /*! |
|
369 | /*! | |
369 | Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget. |
|
370 | Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget. | |
370 | */ |
|
371 | */ | |
371 |
void QChart::setMargins(const QMargins& |
|
372 | void QChart::setMargins(const QMargins &margins) | |
372 | { |
|
373 | { | |
373 | d_ptr->m_presenter->setMargins(margins); |
|
374 | d_ptr->m_presenter->setMargins(margins); | |
374 | } |
|
375 | } | |
@@ -446,7 +447,7 bool QChart::isDropShadowEnabled() const | |||||
446 |
|
447 | |||
447 | \sa addSeries(), removeSeries(), removeAllSeries() |
|
448 | \sa addSeries(), removeSeries(), removeAllSeries() | |
448 | */ |
|
449 | */ | |
449 | QList<QAbstractSeries*> QChart::series() const |
|
450 | QList<QAbstractSeries *> QChart::series() const | |
450 | { |
|
451 | { | |
451 | return d_ptr->m_dataset->series(); |
|
452 | return d_ptr->m_dataset->series(); | |
452 | } |
|
453 | } | |
@@ -456,7 +457,7 QList<QAbstractSeries*> QChart::series() const | |||||
456 |
|
457 | |||
457 | \sa axisX(), axisY(), setAxisY(), createDefaultAxes() |
|
458 | \sa axisX(), axisY(), setAxisY(), createDefaultAxes() | |
458 | */ |
|
459 | */ | |
459 |
void QChart::setAxisX(QAbstractAxis* |
|
460 | void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series) | |
460 | { |
|
461 | { | |
461 | d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal); |
|
462 | d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal); | |
462 | } |
|
463 | } |
@@ -74,22 +74,22 public: | |||||
74 | void addSeries(QAbstractSeries *series); |
|
74 | void addSeries(QAbstractSeries *series); | |
75 | void removeSeries(QAbstractSeries *series); |
|
75 | void removeSeries(QAbstractSeries *series); | |
76 | void removeAllSeries(); |
|
76 | void removeAllSeries(); | |
77 | QList<QAbstractSeries*> series() const; |
|
77 | QList<QAbstractSeries *> series() const; | |
78 |
|
78 | |||
79 |
void setAxisX(QAbstractAxis* |
|
79 | void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0); | |
80 |
void setAxisY(QAbstractAxis* |
|
80 | void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0); | |
81 |
|
81 | |||
82 |
QAbstractAxis* |
|
82 | QAbstractAxis *axisX(QAbstractSeries *series = 0) const; | |
83 |
QAbstractAxis* |
|
83 | QAbstractAxis *axisY(QAbstractSeries *series = 0) const; | |
84 |
|
84 | |||
85 | void createDefaultAxes(); |
|
85 | void createDefaultAxes(); | |
86 |
|
86 | |||
87 | void setTheme(QChart::ChartTheme theme); |
|
87 | void setTheme(QChart::ChartTheme theme); | |
88 | QChart::ChartTheme theme() const; |
|
88 | QChart::ChartTheme theme() const; | |
89 |
|
89 | |||
90 |
void setTitle(const QString& |
|
90 | void setTitle(const QString &title); | |
91 | QString title() const; |
|
91 | QString title() const; | |
92 |
void setTitleFont(const QFont& |
|
92 | void setTitleFont(const QFont &font); | |
93 | QFont titleFont() const; |
|
93 | QFont titleFont() const; | |
94 | void setTitleBrush(const QBrush &brush); |
|
94 | void setTitleBrush(const QBrush &brush); | |
95 | QBrush titleBrush() const; |
|
95 | QBrush titleBrush() const; | |
@@ -112,9 +112,9 public: | |||||
112 | void zoom(qreal factor); |
|
112 | void zoom(qreal factor); | |
113 | void scroll(qreal dx, qreal dy); |
|
113 | void scroll(qreal dx, qreal dy); | |
114 |
|
114 | |||
115 |
QLegend* |
|
115 | QLegend *legend() const; | |
116 |
|
116 | |||
117 |
void setMargins(const QMargins& |
|
117 | void setMargins(const QMargins &margins); | |
118 | QMargins margins() const; |
|
118 | QMargins margins() const; | |
119 |
|
119 | |||
120 | QRectF plotArea() const; |
|
120 | QRectF plotArea() const; |
@@ -42,7 +42,7 struct QChartPrivate | |||||
42 | { |
|
42 | { | |
43 | QChartPrivate(); |
|
43 | QChartPrivate(); | |
44 | ~QChartPrivate(); |
|
44 | ~QChartPrivate(); | |
45 |
QLegend* |
|
45 | QLegend *m_legend; | |
46 | ChartDataSet *m_dataset; |
|
46 | ChartDataSet *m_dataset; | |
47 | ChartPresenter *m_presenter; |
|
47 | ChartPresenter *m_presenter; | |
48 |
|
48 |
@@ -78,8 +78,8 static inline QDebug chartDebug(int numargs,...) | |||||
78 | va_start(valist, numargs); |
|
78 | va_start(valist, numargs); | |
79 | //for( int i = 0 ; i < numargs; i++ ) |
|
79 | //for( int i = 0 ; i < numargs; i++ ) | |
80 | int line = va_arg(valist, int); |
|
80 | int line = va_arg(valist, int); | |
81 |
char* |
|
81 | char *file = va_arg(valist, char *); | |
82 |
char* |
|
82 | char *function = va_arg(valist, char *); | |
83 | va_end(valist); |
|
83 | va_end(valist); | |
84 | return qDebug() << QString().append(function).append("(").append(file).append(":%1)").arg(line); |
|
84 | return qDebug() << QString().append(function).append("(").append(file).append(":%1)").arg(line); | |
85 | } |
|
85 | } |
@@ -82,7 +82,7 QChartView::~QChartView() | |||||
82 | /*! |
|
82 | /*! | |
83 | Returns the pointer to the associated chart |
|
83 | Returns the pointer to the associated chart | |
84 | */ |
|
84 | */ | |
85 |
QChart* |
|
85 | QChart *QChartView::chart() const | |
86 | { |
|
86 | { | |
87 | return d_ptr->m_chart; |
|
87 | return d_ptr->m_chart; | |
88 | } |
|
88 | } | |
@@ -102,7 +102,7 void QChartView::setChart(QChart *chart) | |||||
102 | /*! |
|
102 | /*! | |
103 | Sets the RubberBandPlicy to \a rubberBand. Selected policy determines the way zooming is performed. |
|
103 | Sets the RubberBandPlicy to \a rubberBand. Selected policy determines the way zooming is performed. | |
104 | */ |
|
104 | */ | |
105 |
void QChartView::setRubberBand(const RubberBands& |
|
105 | void QChartView::setRubberBand(const RubberBands &rubberBand) | |
106 | { |
|
106 | { | |
107 | d_ptr->m_rubberBandFlags = rubberBand; |
|
107 | d_ptr->m_rubberBandFlags = rubberBand; | |
108 |
|
108 | |||
@@ -205,7 +205,7 void QChartView::resizeEvent(QResizeEvent *event) | |||||
205 |
|
205 | |||
206 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
206 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
207 |
|
207 | |||
208 |
QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart* |
|
208 | QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart *chart) | |
209 | : q_ptr(q), |
|
209 | : q_ptr(q), | |
210 | m_scene(new QGraphicsScene(q)), |
|
210 | m_scene(new QGraphicsScene(q)), | |
211 | m_chart(chart), |
|
211 | m_chart(chart), |
@@ -1,74 +1,74 | |||||
1 | /**************************************************************************** |
|
1 | /**************************************************************************** | |
2 | ** |
|
2 | ** | |
3 | ** Copyright (C) 2012 Digia Plc |
|
3 | ** Copyright (C) 2012 Digia Plc | |
4 | ** All rights reserved. |
|
4 | ** All rights reserved. | |
5 | ** For any questions to Digia, please use contact form at http://qt.digia.com |
|
5 | ** For any questions to Digia, please use contact form at http://qt.digia.com | |
6 | ** |
|
6 | ** | |
7 | ** This file is part of the Qt Commercial Charts Add-on. |
|
7 | ** This file is part of the Qt Commercial Charts Add-on. | |
8 | ** |
|
8 | ** | |
9 | ** $QT_BEGIN_LICENSE$ |
|
9 | ** $QT_BEGIN_LICENSE$ | |
10 | ** Licensees holding valid Qt Commercial licenses may use this file in |
|
10 | ** Licensees holding valid Qt Commercial licenses may use this file in | |
11 | ** accordance with the Qt Commercial License Agreement provided with the |
|
11 | ** accordance with the Qt Commercial License Agreement provided with the | |
12 | ** Software or, alternatively, in accordance with the terms contained in |
|
12 | ** Software or, alternatively, in accordance with the terms contained in | |
13 | ** a written agreement between you and Digia. |
|
13 | ** a written agreement between you and Digia. | |
14 | ** |
|
14 | ** | |
15 | ** If you have questions regarding the use of this file, please use |
|
15 | ** If you have questions regarding the use of this file, please use | |
16 | ** contact form at http://qt.digia.com |
|
16 | ** contact form at http://qt.digia.com | |
17 | ** $QT_END_LICENSE$ |
|
17 | ** $QT_END_LICENSE$ | |
18 | ** |
|
18 | ** | |
19 | ****************************************************************************/ |
|
19 | ****************************************************************************/ | |
20 |
|
20 | |||
21 | #ifndef QCHARTVIEW_H |
|
21 | #ifndef QCHARTVIEW_H | |
22 | #define QCHARTVIEW_H |
|
22 | #define QCHARTVIEW_H | |
23 |
|
23 | |||
24 | #include <QAbstractAxis> |
|
24 | #include <QAbstractAxis> | |
25 | #include <QAbstractSeries> |
|
25 | #include <QAbstractSeries> | |
26 | #include <QChart> |
|
26 | #include <QChart> | |
27 | #include <QGraphicsView> |
|
27 | #include <QGraphicsView> | |
28 |
|
28 | |||
29 | class QGraphicsScene; |
|
29 | class QGraphicsScene; | |
30 | class QRubberBand; |
|
30 | class QRubberBand; | |
31 |
|
31 | |||
32 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
32 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
33 |
|
33 | |||
34 | class QChartViewPrivate; |
|
34 | class QChartViewPrivate; | |
35 |
|
35 | |||
36 | class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView |
|
36 | class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView | |
37 | { |
|
37 | { | |
38 | Q_OBJECT |
|
38 | Q_OBJECT | |
39 | Q_ENUMS(RubberBand) |
|
39 | Q_ENUMS(RubberBand) | |
40 | public: |
|
40 | public: | |
41 |
|
41 | |||
42 | enum RubberBand { |
|
42 | enum RubberBand { | |
43 | NoRubberBand = 0x0, |
|
43 | NoRubberBand = 0x0, | |
44 | VerticalRubberBand = 0x1, |
|
44 | VerticalRubberBand = 0x1, | |
45 | HorizonalRubberBand = 0x2, |
|
45 | HorizonalRubberBand = 0x2, | |
46 | RectangleRubberBand = 0x3 |
|
46 | RectangleRubberBand = 0x3 | |
47 | }; |
|
47 | }; | |
48 |
|
48 | |||
49 | Q_DECLARE_FLAGS(RubberBands, RubberBand) |
|
49 | Q_DECLARE_FLAGS(RubberBands, RubberBand) | |
50 |
|
50 | |||
51 | explicit QChartView(QWidget *parent = 0); |
|
51 | explicit QChartView(QWidget *parent = 0); | |
52 | explicit QChartView(QChart *chart, QWidget *parent = 0); |
|
52 | explicit QChartView(QChart *chart, QWidget *parent = 0); | |
53 | ~QChartView(); |
|
53 | ~QChartView(); | |
54 |
|
54 | |||
55 |
void setRubberBand(const RubberBands& |
|
55 | void setRubberBand(const RubberBands &rubberBands); | |
56 | RubberBands rubberBand() const; |
|
56 | RubberBands rubberBand() const; | |
57 |
|
57 | |||
58 |
QChart* |
|
58 | QChart *chart() const; | |
59 | void setChart(QChart *chart); |
|
59 | void setChart(QChart *chart); | |
60 |
|
60 | |||
61 | protected: |
|
61 | protected: | |
62 | void resizeEvent(QResizeEvent *event); |
|
62 | void resizeEvent(QResizeEvent *event); | |
63 | void mousePressEvent(QMouseEvent *event); |
|
63 | void mousePressEvent(QMouseEvent *event); | |
64 | void mouseMoveEvent(QMouseEvent *event); |
|
64 | void mouseMoveEvent(QMouseEvent *event); | |
65 | void mouseReleaseEvent(QMouseEvent *event); |
|
65 | void mouseReleaseEvent(QMouseEvent *event); | |
66 |
|
66 | |||
67 | protected: |
|
67 | protected: | |
68 | QScopedPointer<QChartViewPrivate> d_ptr; |
|
68 | QScopedPointer<QChartViewPrivate> d_ptr; | |
69 | Q_DISABLE_COPY(QChartView) |
|
69 | Q_DISABLE_COPY(QChartView) | |
70 | }; |
|
70 | }; | |
71 |
|
71 | |||
72 | QTCOMMERCIALCHART_END_NAMESPACE |
|
72 | QTCOMMERCIALCHART_END_NAMESPACE | |
73 |
|
73 | |||
74 | #endif // QCHARTVIEW_H |
|
74 | #endif // QCHARTVIEW_H |
@@ -243,14 +243,14 void QScatterSeries::setMarkerSize(qreal size) | |||||
243 |
|
243 | |||
244 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
244 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
245 |
|
245 | |||
246 |
QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* |
|
246 | QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q) | |
247 | QXYSeriesPrivate(q), |
|
247 | : QXYSeriesPrivate(q), | |
248 | m_shape(QScatterSeries::MarkerShapeCircle), |
|
248 | m_shape(QScatterSeries::MarkerShapeCircle), | |
249 | m_size(15.0) |
|
249 | m_size(15.0) | |
250 | { |
|
250 | { | |
251 | } |
|
251 | } | |
252 |
|
252 | |||
253 |
ChartElement* |
|
253 | ChartElement *QScatterSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
254 | { |
|
254 | { | |
255 | Q_Q(QScatterSeries); |
|
255 | Q_Q(QScatterSeries); | |
256 | ScatterChartItem *scatter = new ScatterChartItem(q, presenter); |
|
256 | ScatterChartItem *scatter = new ScatterChartItem(q, presenter); |
@@ -37,8 +37,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
37 | class QScatterSeriesPrivate: public QXYSeriesPrivate |
|
37 | class QScatterSeriesPrivate: public QXYSeriesPrivate | |
38 | { |
|
38 | { | |
39 | public: |
|
39 | public: | |
40 |
QScatterSeriesPrivate(QScatterSeries* |
|
40 | QScatterSeriesPrivate(QScatterSeries *q); | |
41 |
ChartElement* |
|
41 | ChartElement *createGraphics(ChartPresenter *presenter); | |
42 |
|
42 | |||
43 | private: |
|
43 | private: | |
44 | QScatterSeries::MarkerShape m_shape; |
|
44 | QScatterSeries::MarkerShape m_shape; |
@@ -64,15 +64,14 void ScatterChartItem::createPoints(int count) | |||||
64 | switch (m_shape) { |
|
64 | switch (m_shape) { | |
65 | case QScatterSeries::MarkerShapeCircle: { |
|
65 | case QScatterSeries::MarkerShapeCircle: { | |
66 | item = new CircleMarker(0, 0, m_size, m_size, this); |
|
66 | item = new CircleMarker(0, 0, m_size, m_size, this); | |
67 |
const QRectF& |
|
67 | const QRectF &rect = item->boundingRect(); | |
68 | item->setPos(-rect.width() / 2, -rect.height() / 2); |
|
68 | item->setPos(-rect.width() / 2, -rect.height() / 2); | |
69 | break; |
|
69 | break; | |
70 | } |
|
70 | } | |
71 |
case QScatterSeries::MarkerShapeRectangle: |
|
71 | case QScatterSeries::MarkerShapeRectangle: | |
72 | item = new RectangleMarker(0, 0, m_size, m_size, this); |
|
72 | item = new RectangleMarker(0, 0, m_size, m_size, this); | |
73 | item->setPos(-m_size / 2, -m_size / 2); |
|
73 | item->setPos(-m_size / 2, -m_size / 2); | |
74 | break; |
|
74 | break; | |
75 | } |
|
|||
76 | default: |
|
75 | default: | |
77 | qWarning() << "Unsupported marker type"; |
|
76 | qWarning() << "Unsupported marker type"; | |
78 | break; |
|
77 | break; | |
@@ -86,7 +85,7 void ScatterChartItem::deletePoints(int count) | |||||
86 | QList<QGraphicsItem *> items = m_items.childItems(); |
|
85 | QList<QGraphicsItem *> items = m_items.childItems(); | |
87 |
|
86 | |||
88 | for (int i = 0; i < count; ++i) { |
|
87 | for (int i = 0; i < count; ++i) { | |
89 |
QGraphicsItem * |
|
88 | QGraphicsItem *item = items.takeLast(); | |
90 | m_markerMap.remove(item); |
|
89 | m_markerMap.remove(item); | |
91 | delete(item); |
|
90 | delete(item); | |
92 | } |
|
91 | } | |
@@ -117,12 +116,12 void ScatterChartItem::updateGeometry() | |||||
117 | if (diff != 0) |
|
116 | if (diff != 0) | |
118 | handleUpdated(); |
|
117 | handleUpdated(); | |
119 |
|
118 | |||
120 | QList<QGraphicsItem*> items = m_items.childItems(); |
|
119 | QList<QGraphicsItem *> items = m_items.childItems(); | |
121 |
|
120 | |||
122 | for (int i = 0; i < points.size(); i++) { |
|
121 | for (int i = 0; i < points.size(); i++) { | |
123 |
QGraphicsItem* |
|
122 | QGraphicsItem *item = items.at(i); | |
124 |
const QPointF& |
|
123 | const QPointF &point = points.at(i); | |
125 |
const QRectF& |
|
124 | const QRectF &rect = item->boundingRect(); | |
126 | m_markerMap[item] = point; |
|
125 | m_markerMap[item] = point; | |
127 | item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2); |
|
126 | item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2); | |
128 | if (!m_visible || !clipRect().contains(point)) |
|
127 | if (!m_visible || !clipRect().contains(point)) | |
@@ -143,13 +142,13 void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * | |||||
143 | Q_UNUSED(widget) |
|
142 | Q_UNUSED(widget) | |
144 | } |
|
143 | } | |
145 |
|
144 | |||
146 |
void ScatterChartItem::setPen(const QPen& |
|
145 | void ScatterChartItem::setPen(const QPen &pen) | |
147 | { |
|
146 | { | |
148 | foreach (QGraphicsItem *item , m_items.childItems()) |
|
147 | foreach (QGraphicsItem *item , m_items.childItems()) | |
149 | static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen); |
|
148 | static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen); | |
150 | } |
|
149 | } | |
151 |
|
150 | |||
152 |
void ScatterChartItem::setBrush(const QBrush& |
|
151 | void ScatterChartItem::setBrush(const QBrush &brush) | |
153 | { |
|
152 | { | |
154 | foreach (QGraphicsItem *item , m_items.childItems()) |
|
153 | foreach (QGraphicsItem *item , m_items.childItems()) | |
155 | static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush); |
|
154 | static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush); |
@@ -80,11 +80,11 class CircleMarker: public QGraphicsEllipseItem | |||||
80 | { |
|
80 | { | |
81 |
|
81 | |||
82 | public: |
|
82 | public: | |
83 | CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent) |
|
83 | CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent) | |
84 | : QGraphicsEllipseItem(x, y, w, h, parent), |
|
84 | : QGraphicsEllipseItem(x, y, w, h, parent), | |
85 | m_parent(parent) |
|
85 | m_parent(parent) | |
86 | { |
|
86 | { | |
87 | } |
|
87 | } | |
88 |
|
88 | |||
89 | protected: |
|
89 | protected: | |
90 | void mousePressEvent(QGraphicsSceneMouseEvent *event) |
|
90 | void mousePressEvent(QGraphicsSceneMouseEvent *event) | |
@@ -94,7 +94,7 protected: | |||||
94 | } |
|
94 | } | |
95 |
|
95 | |||
96 | private: |
|
96 | private: | |
97 |
ScatterChartItem* |
|
97 | ScatterChartItem *m_parent; | |
98 | }; |
|
98 | }; | |
99 |
|
99 | |||
100 | class RectangleMarker: public QGraphicsRectItem |
|
100 | class RectangleMarker: public QGraphicsRectItem | |
@@ -115,7 +115,7 protected: | |||||
115 | } |
|
115 | } | |
116 |
|
116 | |||
117 | private: |
|
117 | private: | |
118 |
ScatterChartItem* |
|
118 | ScatterChartItem *m_parent; | |
119 | }; |
|
119 | }; | |
120 |
|
120 | |||
121 | QTCOMMERCIALCHART_END_NAMESPACE |
|
121 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -38,7 +38,7 Scroller::~Scroller() | |||||
38 | { |
|
38 | { | |
39 | } |
|
39 | } | |
40 |
|
40 | |||
41 |
void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* |
|
41 | void Scroller::mousePressEvent(QGraphicsSceneMouseEvent *event) | |
42 | { |
|
42 | { | |
43 | if (event->button() == Qt::LeftButton) { |
|
43 | if (event->button() == Qt::LeftButton) { | |
44 | switch (m_state) { |
|
44 | switch (m_state) { | |
@@ -66,7 +66,7 void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* event) | |||||
66 | } |
|
66 | } | |
67 | } |
|
67 | } | |
68 |
|
68 | |||
69 |
void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent* |
|
69 | void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent *event) | |
70 | { |
|
70 | { | |
71 | QPointF delta = event->pos() - m_press; |
|
71 | QPointF delta = event->pos() - m_press; | |
72 |
|
72 | |||
@@ -96,7 +96,7 void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent* event) | |||||
96 | } |
|
96 | } | |
97 | } |
|
97 | } | |
98 |
|
98 | |||
99 |
void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent* |
|
99 | void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) | |
100 | { |
|
100 | { | |
101 | if (event->button() == Qt::LeftButton) { |
|
101 | if (event->button() == Qt::LeftButton) { | |
102 |
|
102 | |||
@@ -163,7 +163,7 void Scroller::scrollTick() | |||||
163 | } |
|
163 | } | |
164 | } |
|
164 | } | |
165 |
|
165 | |||
166 |
void Scroller::lowerSpeed(QPointF& |
|
166 | void Scroller::lowerSpeed(QPointF &speed, qreal maxSpeed) | |
167 | { |
|
167 | { | |
168 | qreal x = qBound(-maxSpeed, speed.x(), maxSpeed); |
|
168 | qreal x = qBound(-maxSpeed, speed.x(), maxSpeed); | |
169 | qreal y = qBound(-maxSpeed, speed.y(), maxSpeed); |
|
169 | qreal y = qBound(-maxSpeed, speed.y(), maxSpeed); | |
@@ -176,7 +176,7 void Scroller::lowerSpeed(QPointF& speed, qreal maxSpeed) | |||||
176 | speed.setY(y); |
|
176 | speed.setY(y); | |
177 | } |
|
177 | } | |
178 |
|
178 | |||
179 |
void Scroller::calculateSpeed(const QPointF& |
|
179 | void Scroller::calculateSpeed(const QPointF &position) | |
180 | { |
|
180 | { | |
181 | if (m_timeStamp.elapsed() > m_timeTreshold) { |
|
181 | if (m_timeStamp.elapsed() > m_timeTreshold) { | |
182 |
|
182 | |||
@@ -200,7 +200,7 void Scroller::calculateSpeed(const QPointF& position) | |||||
200 |
|
200 | |||
201 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
201 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
202 |
|
202 | |||
203 |
ScrollTicker::ScrollTicker(Scroller *scroller, QObject* |
|
203 | ScrollTicker::ScrollTicker(Scroller *scroller, QObject *parent) | |
204 | : QObject(parent), |
|
204 | : QObject(parent), | |
205 | m_scroller(scroller) |
|
205 | m_scroller(scroller) | |
206 | { |
|
206 | { |
@@ -71,20 +71,20 public: | |||||
71 | Scroller(); |
|
71 | Scroller(); | |
72 | virtual ~Scroller(); |
|
72 | virtual ~Scroller(); | |
73 |
|
73 | |||
74 |
virtual void setOffset(const QPointF& |
|
74 | virtual void setOffset(const QPointF &point) = 0; | |
75 | virtual QPointF offset() const = 0; |
|
75 | virtual QPointF offset() const = 0; | |
76 |
|
76 | |||
77 | public: |
|
77 | public: | |
78 | void scrollTick(); |
|
78 | void scrollTick(); | |
79 |
|
79 | |||
80 | public: |
|
80 | public: | |
81 |
void mousePressEvent(QGraphicsSceneMouseEvent* |
|
81 | void mousePressEvent(QGraphicsSceneMouseEvent *event); | |
82 |
void mouseMoveEvent(QGraphicsSceneMouseEvent* |
|
82 | void mouseMoveEvent(QGraphicsSceneMouseEvent *event); | |
83 |
void mouseReleaseEvent(QGraphicsSceneMouseEvent* |
|
83 | void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); | |
84 |
|
84 | |||
85 | private: |
|
85 | private: | |
86 |
void calculateSpeed(const QPointF& |
|
86 | void calculateSpeed(const QPointF &position); | |
87 |
void lowerSpeed(QPointF& |
|
87 | void lowerSpeed(QPointF &speed, qreal maxSpeed = 100); | |
88 |
|
88 | |||
89 | private: |
|
89 | private: | |
90 | ScrollTicker m_ticker; |
|
90 | ScrollTicker m_ticker; |
@@ -125,7 +125,7 QAbstractSeries::SeriesType QSplineSeries::type() const | |||||
125 |
|
125 | |||
126 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
126 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
127 |
|
127 | |||
128 |
QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* |
|
128 | QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries *q) | |
129 | : QLineSeriesPrivate(q) |
|
129 | : QLineSeriesPrivate(q) | |
130 | { |
|
130 | { | |
131 | } |
|
131 | } | |
@@ -244,7 +244,7 void QSplineSeriesPrivate::updateControlPoints() | |||||
244 | } |
|
244 | } | |
245 | } |
|
245 | } | |
246 |
|
246 | |||
247 |
ChartElement* |
|
247 | ChartElement *QSplineSeriesPrivate::createGraphics(ChartPresenter *presenter) | |
248 | { |
|
248 | { | |
249 | Q_Q(QSplineSeries); |
|
249 | Q_Q(QSplineSeries); | |
250 | SplineChartItem *spline = new SplineChartItem(q, presenter); |
|
250 | SplineChartItem *spline = new SplineChartItem(q, presenter); |
@@ -39,8 +39,8 class QSplineSeriesPrivate: public QLineSeriesPrivate | |||||
39 | { |
|
39 | { | |
40 | Q_OBJECT |
|
40 | Q_OBJECT | |
41 | public: |
|
41 | public: | |
42 |
ChartElement* |
|
42 | ChartElement *createGraphics(ChartPresenter *presenter); | |
43 |
QSplineSeriesPrivate(QSplineSeries* |
|
43 | QSplineSeriesPrivate(QSplineSeries *q); | |
44 |
|
44 | |||
45 | QPointF controlPoint(int index) const; |
|
45 | QPointF controlPoint(int index) const; | |
46 |
|
46 |
@@ -51,13 +51,13 QPainterPath SplineChartItem::shape() const | |||||
51 | return m_path; |
|
51 | return m_path; | |
52 | } |
|
52 | } | |
53 |
|
53 | |||
54 |
void SplineChartItem::setAnimation(SplineAnimation* |
|
54 | void SplineChartItem::setAnimation(SplineAnimation *animation) | |
55 | { |
|
55 | { | |
56 | m_animation = animation; |
|
56 | m_animation = animation; | |
57 | XYChart::setAnimation(animation); |
|
57 | XYChart::setAnimation(animation); | |
58 | } |
|
58 | } | |
59 |
|
59 | |||
60 |
ChartAnimation* |
|
60 | ChartAnimation *SplineChartItem::animation() const | |
61 | { |
|
61 | { | |
62 | return m_animation; |
|
62 | return m_animation; | |
63 | } |
|
63 | } | |
@@ -119,7 +119,7 void SplineChartItem::updateGeometry() | |||||
119 | QPainterPath splinePath(points.at(0)); |
|
119 | QPainterPath splinePath(points.at(0)); | |
120 |
|
120 | |||
121 | for (int i = 0; i < points.size() - 1; i++) { |
|
121 | for (int i = 0; i < points.size() - 1; i++) { | |
122 |
const QPointF& |
|
122 | const QPointF &point = points.at(i + 1); | |
123 | splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point); |
|
123 | splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point); | |
124 | } |
|
124 | } | |
125 |
|
125 |
@@ -52,8 +52,8 public: | |||||
52 | void setControlGeometryPoints(QVector<QPointF>& points); |
|
52 | void setControlGeometryPoints(QVector<QPointF>& points); | |
53 | QVector<QPointF> controlGeometryPoints() const; |
|
53 | QVector<QPointF> controlGeometryPoints() const; | |
54 |
|
54 | |||
55 |
void setAnimation(SplineAnimation* |
|
55 | void setAnimation(SplineAnimation *animation); | |
56 |
ChartAnimation* |
|
56 | ChartAnimation *animation() const; | |
57 |
|
57 | |||
58 | public Q_SLOTS: |
|
58 | public Q_SLOTS: | |
59 | void handleUpdated(); |
|
59 | void handleUpdated(); | |
@@ -74,7 +74,7 private: | |||||
74 | QPen m_pointPen; |
|
74 | QPen m_pointPen; | |
75 | bool m_pointsVisible; |
|
75 | bool m_pointsVisible; | |
76 | QVector<QPointF> m_controlPoints; |
|
76 | QVector<QPointF> m_controlPoints; | |
77 |
SplineAnimation* |
|
77 | SplineAnimation *m_animation; | |
78 |
|
78 | |||
79 | friend class SplineAnimation; |
|
79 | friend class SplineAnimation; | |
80 | }; |
|
80 | }; |
@@ -149,7 +149,7 QHXYModelMapper::QHXYModelMapper(QObject *parent) : | |||||
149 | QXYModelMapper::setOrientation(Qt::Horizontal); |
|
149 | QXYModelMapper::setOrientation(Qt::Horizontal); | |
150 | } |
|
150 | } | |
151 |
|
151 | |||
152 |
QAbstractItemModel* |
|
152 | QAbstractItemModel *QHXYModelMapper::model() const | |
153 | { |
|
153 | { | |
154 | return QXYModelMapper::model(); |
|
154 | return QXYModelMapper::model(); | |
155 | } |
|
155 | } | |
@@ -162,7 +162,7 void QHXYModelMapper::setModel(QAbstractItemModel *model) | |||||
162 | } |
|
162 | } | |
163 | } |
|
163 | } | |
164 |
|
164 | |||
165 |
QXYSeries* |
|
165 | QXYSeries *QHXYModelMapper::series() const | |
166 | { |
|
166 | { | |
167 | return QXYModelMapper::series(); |
|
167 | return QXYModelMapper::series(); | |
168 | } |
|
168 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QHXYModelMapper : public QXYModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QHXYModelMapper(QObject *parent = 0); |
|
39 | explicit QHXYModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QXYSeries* |
|
44 | QXYSeries *series() const; | |
45 | void setSeries(QXYSeries *series); |
|
45 | void setSeries(QXYSeries *series); | |
46 |
|
46 | |||
47 | int xRow() const; |
|
47 | int xRow() const; |
@@ -149,7 +149,7 QVXYModelMapper::QVXYModelMapper(QObject *parent) : | |||||
149 | QXYModelMapper::setOrientation(Qt::Vertical); |
|
149 | QXYModelMapper::setOrientation(Qt::Vertical); | |
150 | } |
|
150 | } | |
151 |
|
151 | |||
152 |
QAbstractItemModel* |
|
152 | QAbstractItemModel *QVXYModelMapper::model() const | |
153 | { |
|
153 | { | |
154 | return QXYModelMapper::model(); |
|
154 | return QXYModelMapper::model(); | |
155 | } |
|
155 | } | |
@@ -162,7 +162,7 void QVXYModelMapper::setModel(QAbstractItemModel *model) | |||||
162 | } |
|
162 | } | |
163 | } |
|
163 | } | |
164 |
|
164 | |||
165 |
QXYSeries* |
|
165 | QXYSeries *QVXYModelMapper::series() const | |
166 | { |
|
166 | { | |
167 | return QXYModelMapper::series(); |
|
167 | return QXYModelMapper::series(); | |
168 | } |
|
168 | } |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QVXYModelMapper : public QXYModelMapper | |||||
38 | public: |
|
38 | public: | |
39 | explicit QVXYModelMapper(QObject *parent = 0); |
|
39 | explicit QVXYModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QXYSeries* |
|
44 | QXYSeries *series() const; | |
45 | void setSeries(QXYSeries *series); |
|
45 | void setSeries(QXYSeries *series); | |
46 |
|
46 | |||
47 | int xColumn() const; |
|
47 | int xColumn() const; |
@@ -37,7 +37,7 QXYModelMapper::QXYModelMapper(QObject *parent): | |||||
37 | /*! |
|
37 | /*! | |
38 | \internal |
|
38 | \internal | |
39 | */ |
|
39 | */ | |
40 |
QAbstractItemModel* |
|
40 | QAbstractItemModel *QXYModelMapper::model() const | |
41 | { |
|
41 | { | |
42 | Q_D(const QXYModelMapper); |
|
42 | Q_D(const QXYModelMapper); | |
43 | return d->m_model; |
|
43 | return d->m_model; | |
@@ -69,7 +69,7 void QXYModelMapper::setModel(QAbstractItemModel *model) | |||||
69 | /*! |
|
69 | /*! | |
70 | \internal |
|
70 | \internal | |
71 | */ |
|
71 | */ | |
72 |
QXYSeries* |
|
72 | QXYSeries *QXYModelMapper::series() const | |
73 | { |
|
73 | { | |
74 | Q_D(const QXYModelMapper); |
|
74 | Q_D(const QXYModelMapper); | |
75 | return d->m_series; |
|
75 | return d->m_series; |
@@ -38,10 +38,10 class QTCOMMERCIALCHART_EXPORT QXYModelMapper : public QObject | |||||
38 | protected: |
|
38 | protected: | |
39 | explicit QXYModelMapper(QObject *parent = 0); |
|
39 | explicit QXYModelMapper(QObject *parent = 0); | |
40 |
|
40 | |||
41 |
QAbstractItemModel* |
|
41 | QAbstractItemModel *model() const; | |
42 | void setModel(QAbstractItemModel *model); |
|
42 | void setModel(QAbstractItemModel *model); | |
43 |
|
43 | |||
44 |
QXYSeries* |
|
44 | QXYSeries *series() const; | |
45 | void setSeries(QXYSeries *series); |
|
45 | void setSeries(QXYSeries *series); | |
46 |
|
46 | |||
47 | int first() const; |
|
47 | int first() const; | |
@@ -60,7 +60,7 protected: | |||||
60 | void setYSection(int ySection); |
|
60 | void setYSection(int ySection); | |
61 |
|
61 | |||
62 | protected: |
|
62 | protected: | |
63 |
QXYModelMapperPrivate * |
|
63 | QXYModelMapperPrivate *const d_ptr; | |
64 | Q_DECLARE_PRIVATE(QXYModelMapper) |
|
64 | Q_DECLARE_PRIVATE(QXYModelMapper) | |
65 | }; |
|
65 | }; | |
66 |
|
66 |
@@ -390,7 +390,7 bool QXYSeries::pointsVisible() const | |||||
390 | Stream operator for adding a data \a point to the series. |
|
390 | Stream operator for adding a data \a point to the series. | |
391 | \sa append() |
|
391 | \sa append() | |
392 | */ |
|
392 | */ | |
393 |
QXYSeries& |
|
393 | QXYSeries &QXYSeries::operator<< (const QPointF &point) | |
394 | { |
|
394 | { | |
395 | append(point); |
|
395 | append(point); | |
396 | return *this; |
|
396 | return *this; | |
@@ -402,7 +402,7 QXYSeries& QXYSeries::operator<< (const QPointF &point) | |||||
402 | \sa append() |
|
402 | \sa append() | |
403 | */ |
|
403 | */ | |
404 |
|
404 | |||
405 |
QXYSeries& |
|
405 | QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points) | |
406 | { |
|
406 | { | |
407 | append(points); |
|
407 | append(points); | |
408 | return *this; |
|
408 | return *this; | |
@@ -411,13 +411,13 QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points) | |||||
411 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
411 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
412 |
|
412 | |||
413 |
|
413 | |||
414 |
QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) |
|
414 | QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) | |
415 | QAbstractSeriesPrivate(q), |
|
415 | : QAbstractSeriesPrivate(q), | |
416 | m_pointsVisible(false) |
|
416 | m_pointsVisible(false) | |
417 | { |
|
417 | { | |
418 | } |
|
418 | } | |
419 |
|
419 | |||
420 |
void QXYSeriesPrivate::scaleDomain(Domain& |
|
420 | void QXYSeriesPrivate::scaleDomain(Domain &domain) | |
421 | { |
|
421 | { | |
422 | qreal minX(0); |
|
422 | qreal minX(0); | |
423 | qreal minY(0); |
|
423 | qreal minY(0); | |
@@ -447,14 +447,14 void QXYSeriesPrivate::scaleDomain(Domain& domain) | |||||
447 | domain.setRange(minX, maxX, minY, maxY); |
|
447 | domain.setRange(minX, maxX, minY, maxY); | |
448 | } |
|
448 | } | |
449 |
|
449 | |||
450 |
QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* |
|
450 | QList<LegendMarker *> QXYSeriesPrivate::createLegendMarker(QLegend *legend) | |
451 | { |
|
451 | { | |
452 | Q_Q(QXYSeries); |
|
452 | Q_Q(QXYSeries); | |
453 | QList<LegendMarker*> list; |
|
453 | QList<LegendMarker *> list; | |
454 | return list << new XYLegendMarker(q, legend); |
|
454 | return list << new XYLegendMarker(q, legend); | |
455 | } |
|
455 | } | |
456 |
|
456 | |||
457 |
void QXYSeriesPrivate::initializeAxis(QAbstractAxis* |
|
457 | void QXYSeriesPrivate::initializeAxis(QAbstractAxis *axis) | |
458 | { |
|
458 | { | |
459 | Q_UNUSED(axis); |
|
459 | Q_UNUSED(axis); | |
460 | } |
|
460 | } |
@@ -57,8 +57,8 public: | |||||
57 | int count() const; |
|
57 | int count() const; | |
58 | QList<QPointF> points() const; |
|
58 | QList<QPointF> points() const; | |
59 |
|
59 | |||
60 |
QXYSeries& |
|
60 | QXYSeries &operator << (const QPointF &point); | |
61 |
QXYSeries& |
|
61 | QXYSeries &operator << (const QList<QPointF> &points); | |
62 |
|
62 | |||
63 | virtual void setPen(const QPen &pen); |
|
63 | virtual void setPen(const QPen &pen); | |
64 | QPen pen() const; |
|
64 | QPen pen() const; |
@@ -42,12 +42,12 class QXYSeriesPrivate: public QAbstractSeriesPrivate | |||||
42 | Q_OBJECT |
|
42 | Q_OBJECT | |
43 |
|
43 | |||
44 | public: |
|
44 | public: | |
45 |
QXYSeriesPrivate(QXYSeries* |
|
45 | QXYSeriesPrivate(QXYSeries *q); | |
46 |
|
46 | |||
47 |
void scaleDomain(Domain& |
|
47 | void scaleDomain(Domain &domain); | |
48 |
QList<LegendMarker*> createLegendMarker(QLegend* |
|
48 | QList<LegendMarker *> createLegendMarker(QLegend *legend); | |
49 |
|
49 | |||
50 |
void initializeAxis(QAbstractAxis* |
|
50 | void initializeAxis(QAbstractAxis *axis); | |
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; |
|
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
52 |
|
52 | |||
53 | Q_SIGNALS: |
|
53 | Q_SIGNALS: |
@@ -59,7 +59,7 void XYChart::setClipRect(const QRectF &rect) | |||||
59 | m_clipRect = rect; |
|
59 | m_clipRect = rect; | |
60 | } |
|
60 | } | |
61 |
|
61 | |||
62 |
void XYChart::setAnimation(XYAnimation* |
|
62 | void XYChart::setAnimation(XYAnimation *animation) | |
63 | { |
|
63 | { | |
64 | m_animation = animation; |
|
64 | m_animation = animation; | |
65 | } |
|
65 | } |
@@ -57,8 +57,8 public: | |||||
57 | QSizeF size() const { return m_size; } |
|
57 | QSizeF size() const { return m_size; } | |
58 | QPointF origin() const { return m_origin; } |
|
58 | QPointF origin() const { return m_origin; } | |
59 |
|
59 | |||
60 |
void setAnimation(XYAnimation* |
|
60 | void setAnimation(XYAnimation *animation); | |
61 |
ChartAnimation* |
|
61 | ChartAnimation *animation() const { return m_animation; } | |
62 | virtual void updateGeometry() = 0; |
|
62 | virtual void updateGeometry() = 0; | |
63 |
|
63 | |||
64 | bool isDirty() const { return m_dirty; } |
|
64 | bool isDirty() const { return m_dirty; } | |
@@ -73,7 +73,7 public Q_SLOTS: | |||||
73 | void handleGeometryChanged(const QRectF &size); |
|
73 | void handleGeometryChanged(const QRectF &size); | |
74 |
|
74 | |||
75 | Q_SIGNALS: |
|
75 | Q_SIGNALS: | |
76 |
void clicked(const QPointF& |
|
76 | void clicked(const QPointF &point); | |
77 |
|
77 | |||
78 | protected: |
|
78 | protected: | |
79 | virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1); |
|
79 | virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1); | |
@@ -90,12 +90,12 protected: | |||||
90 | qreal m_maxX; |
|
90 | qreal m_maxX; | |
91 | qreal m_minY; |
|
91 | qreal m_minY; | |
92 | qreal m_maxY; |
|
92 | qreal m_maxY; | |
93 |
QXYSeries* |
|
93 | QXYSeries *m_series; | |
94 | QSizeF m_size; |
|
94 | QSizeF m_size; | |
95 | QPointF m_origin; |
|
95 | QPointF m_origin; | |
96 | QRectF m_clipRect; |
|
96 | QRectF m_clipRect; | |
97 | QVector<QPointF> m_points; |
|
97 | QVector<QPointF> m_points; | |
98 |
XYAnimation* |
|
98 | XYAnimation *m_animation; | |
99 | bool m_dirty; |
|
99 | bool m_dirty; | |
100 |
|
100 | |||
101 | friend class AreaChartItem; |
|
101 | friend class AreaChartItem; |
General Comments 0
You need to be logged in to leave comments.
Login now