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

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

Refactors layout:...
Michal Klocek -
r2105:984dd120480b
parent child
Show More
Side by Side Unified
Context file:
r2105:984dd120480b Loading diff...:
Show file before | Show file after | Hide comments
@@ -48,13 +48,21 int main(int argc, char *argv[])
48 axisX = new QValueAxis;
48 axisX = new QValueAxis;
49 axisX->setTickCount(7 + i);
49 axisX->setTickCount(7 + i);
50 axisX->setLinePenColor(series->pen().color());
50 axisX->setLinePenColor(series->pen().color());
51
51 if (i % 2)
52 if (i % 2)
52 axisX->setAlternativePlacement(true);
53 axisX->setAlignment(Qt::AlignTop);
54 else
55 axisX->setAlignment(Qt::AlignBottom);
56
53 axisY = new QValueAxis;
57 axisY = new QValueAxis;
54 axisY->setTickCount(7 + i);
58 axisY->setTickCount(7 + i);
55 axisY->setLinePenColor(series->pen().color());
59 axisY->setLinePenColor(series->pen().color());
60
56 if (i % 2)
61 if (i % 2)
57 axisY->setAlternativePlacement(true);
62 axisY->setAlignment(Qt::AlignRight);
63 else
64 axisY->setAlignment(Qt::AlignLeft);
65
58
66
59 chart->setAxisX(axisX, series);
67 chart->setAxisX(axisX, series);
60 chart->setAxisY(axisY, series);
68 chart->setAxisY(axisY, series);
Show file before | Show file after | Hide comments
@@ -58,15 +58,14 void AxisAnimation::setAnimationPoint(const QPointF &point)
58
58
59 void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
59 void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
60 {
60 {
61 if (state() != QAbstractAnimation::Stopped)
61 if (state() != QAbstractAnimation::Stopped) stop();
62 stop();
63
62
64 if (newLayout.count() == 0)
63 if (newLayout.count() == 0)
65 return;
64 return;
66
65
67 switch (m_type) {
66 switch (m_type) {
68 case ZoomOutAnimation: {
67 case ZoomOutAnimation: {
69 QRectF rect = m_axis->presenter()->chartsGeometry();
68 QRectF rect = m_axis->gridGeometry();
70 oldLayout.resize(newLayout.count());
69 oldLayout.resize(newLayout.count());
71
70
72 for (int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
71 for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
@@ -76,8 +75,7 void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayo
76 }
75 }
77 break;
76 break;
78 case ZoomInAnimation: {
77 case ZoomInAnimation: {
79 int index = qMin(oldLayout.count() * (m_axis->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())),
78 int index = qMin(oldLayout.count() * (m_axis->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
80 newLayout.count() - (qreal)1.0);
81 oldLayout.resize(newLayout.count());
79 oldLayout.resize(newLayout.count());
82
80
83 for (int i = 0; i < oldLayout.count(); i++)
81 for(int i = 0; i < oldLayout.count(); i++)
@@ -100,7 +98,7 void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayo
100 break;
98 break;
101 default: {
99 default: {
102 oldLayout.resize(newLayout.count());
100 oldLayout.resize(newLayout.count());
103 QRectF rect = m_axis->presenter()->chartsGeometry();
101 QRectF rect = m_axis->gridGeometry();
104 for (int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
102 for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
105 oldLayout[i] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
103 oldLayout[i] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
106 }
104 }
Show file before | Show file after | Hide comments
@@ -29,8 +29,7 static int label_padding = 5;
29
29
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
31
31
32 ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter)
32 ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
33 : ChartAxis(axis, presenter),
34 m_categoriesAxis(axis)
33 m_categoriesAxis(axis)
35 {
34 {
36
35
@@ -49,23 +48,23 QVector<qreal> ChartBarCategoryAxisX::calculateLayout() const
49 QVector<qreal> points;
48 QVector<qreal> points;
50 points.resize(count + 2);
49 points.resize(count+2);
51
50
52 QRectF rect = presenter()->chartsGeometry();
51 const qreal delta = m_gridRect.width()/(count);
53
54 const qreal delta = rect.width() / (count);
55 qreal offset = -m_min - 0.5;
52 qreal offset =-m_min-0.5;
56
53
57 if (delta < 1) return points;
54 if(delta<1) return points;
58
55
59 if (offset <= 0)
56 if(offset<=0) {
60 offset = int(offset * rect.width() / (m_max - m_min)) % int(delta) + delta;
57 offset = int(offset * m_gridRect.width()/(m_max - m_min))%int(delta) + delta;
61 else
58 }
62 offset = int(offset * rect.width() / (m_max - m_min)) % int(delta);
59 else {
60 offset = int(offset * m_gridRect.width()/(m_max - m_min))%int(delta);
61 }
63
62
64 points[0] = rect.left();
63 points[0] = m_gridRect.left();
65 points[count + 1] = rect.right();
64 points[count+1] = m_gridRect.right();
66
65
67 for (int i = 0; i < count; ++i) {
66 for (int i = 0; i < count; ++i) {
68 qreal x = offset + i * delta + rect.left();
67 qreal x = offset + i * delta + m_gridRect.left();
69 points[i + 1] = x;
68 points[i+1] = x;
70 }
69 }
71 return points;
70 return points;
@@ -74,14 +73,17 QVector<qreal> ChartBarCategoryAxisX::calculateLayout() const
74 QStringList ChartBarCategoryAxisX::createCategoryLabels(const QVector<qreal>& layout) const
73 QStringList ChartBarCategoryAxisX::createCategoryLabels(const QVector<qreal>& layout) const
75 {
74 {
76 QStringList result;
75 QStringList result;
77 QRectF rect = presenter()->chartsGeometry();
76
78 qreal d = (m_max - m_min) / rect.width();
77 qreal d = (m_max - m_min)/m_gridRect.width();
79 for (int i = 0; i < layout.count() - 1; ++i) {
78 for (int i = 0;i < layout.count()-1; ++i) {
80 qreal x = qFloor((((layout[i + 1] + layout[i]) / 2 - rect.left()) * d + m_min + 0.5));
79 qreal x = qFloor((((layout[i+1] + layout[i])/2-m_gridRect.left())*d + m_min+0.5));
81 if ((x < m_categoriesAxis->categories().count()) && (x >= 0))
80 if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
82 result << m_categoriesAxis->categories().at(x);
81 result << m_categoriesAxis->categories().at(x);
83 else
82 }
84 result << ""; // No label for x coordinate
83 else {
84 // No label for x coordinate
85 result << "";
86 }
85 }
87 }
86 result << "";
88 result << "";
87 return result;
89 return result;
@@ -92,8 +94,7 void ChartBarCategoryAxisX::updateGeometry()
92 {
94 {
93 const QVector<qreal>& layout = ChartAxis::layout();
95 const QVector<qreal>& layout = ChartAxis::layout();
94
96
95 if (layout.isEmpty())
97 if(layout.isEmpty()) return;
96 return;
97
98
98 QStringList ticksList = createCategoryLabels(layout);
99 QStringList ticksList = createCategoryLabels(layout);
99
100
@@ -105,47 +106,48 void ChartBarCategoryAxisX::updateGeometry()
105 Q_ASSERT(labels.size() == ticksList.size());
106 Q_ASSERT(labels.size() == ticksList.size());
106 Q_ASSERT(layout.size() == ticksList.size());
107 Q_ASSERT(layout.size() == ticksList.size());
107
108
108 QRectF chartRect = presenter()->chartsGeometry();
109 const qreal delta = m_gridRect.width()/(m_categoriesAxis->d_ptr->count());
109
110 const qreal delta = chartRect.width() / (m_categoriesAxis->d_ptr->count());
111
110
112 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
111 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
113 lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
112 lineItem->setLine( m_gridRect.left(), m_gridRect.bottom(), m_gridRect.right(), m_gridRect.bottom());
114
113
115 qreal width = chartRect.left();
114 qreal width = m_gridRect.left();
116 for (int i = 0; i < layout.size(); ++i) {
115 for (int i = 0; i < layout.size(); ++i) {
117 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
116 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
118 lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom());
117 lineItem->setLine(layout[i], m_gridRect.top(), layout[i], m_gridRect.bottom());
119 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
118 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
120 labelItem->setText(ticksList.at(i));
119 labelItem->setText(ticksList.at(i));
121 const QRectF &rect = labelItem->boundingRect();
120 const QRectF& rect = labelItem->boundingRect();
122 QPointF center = rect.center();
121 QPointF center = rect.center();
123 labelItem->setTransformOriginPoint(center.x(), center.y());
122 labelItem->setTransformOriginPoint(center.x(), center.y());
124
123
125 if (i == 0)
124 if(i==0){
126 labelItem->setPos(layout[i + 1] - (delta) / 2 - center.x(), chartRect.bottom() + label_padding);
125 labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_gridRect.bottom() + label_padding);
127 else
126 }else{
128 labelItem->setPos(layout[i] + (delta) / 2 - center.x(), chartRect.bottom() + label_padding);
127 labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_gridRect.bottom() + label_padding);
128 }
129
129
130 if (labelItem->pos().x() <= width || labelItem->pos().x() + rect.width() > chartRect.right()) {
130 if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()> m_gridRect.right()) {
131 labelItem->setVisible(false);
131 labelItem->setVisible(false);
132 } else {
132 }
133 else {
133 labelItem->setVisible(true);
134 labelItem->setVisible(true);
134 width = rect.width() + labelItem->pos().x();
135 width=rect.width()+labelItem->pos().x();
135 }
136 }
136
137
137 if ((i + 1) % 2 && i > 1) {
138 if ((i+1)%2 && i>1) {
138 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
139 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());
140 rectItem->setRect(layout[i-1], m_gridRect.top(),layout[i]-layout[i-1], m_gridRect.height());
140 }
141 }
141 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
142 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
142 lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5);
143 lineItem->setLine(layout[i], m_gridRect.bottom(),layout[i], m_gridRect.bottom()+5);
143 }
144 }
144 }
145 }
145
146
146 void ChartBarCategoryAxisX::handleAxisUpdated()
147 void ChartBarCategoryAxisX::handleAxisUpdated()
147 {
148 {
148 if (m_categoriesAxis->categories() != m_categories) {
149 if(m_categoriesAxis->categories()!=m_categories)
150 {
149 m_categories = m_categoriesAxis->categories();
151 m_categories=m_categoriesAxis->categories();
150 if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2) updateGeometry();
152 if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) updateGeometry();
151 }
153 }
@@ -171,8 +173,10 QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constra
171 height += base.height();
173 height+=base.height();
172 sh = QSizeF(width, height);
174 sh = QSizeF(width,height);
173 break;
175 break;
174 case Qt::PreferredSize:
176 case Qt::PreferredSize:{
175 for (int i = 0; i < ticksList.size(); ++i) {
177
178 for (int i = 0; i < ticksList.size(); ++i)
179 {
176 QRectF rect = fn.boundingRect(ticksList.at(i));
180 QRectF rect = fn.boundingRect(ticksList.at(i));
177 width += rect.width();
181 width+=rect.width();
178 height = qMax(rect.height() + label_padding, height);
182 height=qMax(rect.height()+label_padding,height);
@@ -181,6 +185,7 QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constra
181 height += base.height();
185 height+=base.height();
182 sh = QSizeF(width, height);
186 sh = QSizeF(width,height);
183 break;
187 break;
188 }
184 default:
189 default:
185 break;
190 break;
186 }
191 }
Show file before | Show file after | Hide comments
@@ -29,8 +29,7 static int label_padding = 5;
29
29
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
31
31
32 ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter)
32 ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
33 : ChartAxis(axis, presenter),
34 m_categoriesAxis(axis)
33 m_categoriesAxis(axis)
35 {
34 {
36 }
35 }
@@ -48,23 +47,23 QVector<qreal> ChartBarCategoryAxisY::calculateLayout() const
48 QVector<qreal> points;
47 QVector<qreal> points;
49 points.resize(count + 2);
48 points.resize(count+2);
50
49
51 QRectF rect = presenter()->chartsGeometry();
50 const qreal delta = m_gridRect.height()/(count);
52
53 const qreal delta = rect.height() / (count);
54 qreal offset = - m_min - 0.5;
51 qreal offset = - m_min - 0.5;
55
52
56 if (delta < 1) return points;
53 if(delta<1) return points;
57
54
58 if (offset <= 0)
55 if(offset<=0) {
59 offset = int(offset * rect.height() / (m_max - m_min)) % int(delta) + delta;
56 offset = int(offset * m_gridRect.height()/(m_max - m_min))%int(delta) + delta;
60 else
57 }
61 offset = int(offset * rect.height() / (m_max - m_min)) % int(delta);
58 else {
59 offset = int(offset * m_gridRect.height()/(m_max - m_min))%int(delta);
60 }
62
61
63 points[0] = rect.bottom();
62 points[0] = m_gridRect.bottom();
64 points[count + 1] = rect.top();
63 points[count+1] = m_gridRect.top();
65
64
66 for (int i = 0; i < count; ++i) {
65 for (int i = 0; i < count; ++i) {
67 int y = rect.bottom() - i * delta - offset;
66 int y = m_gridRect.bottom() - i * delta - offset;
68 points[i + 1] = y;
67 points[i+1] = y;
69 }
68 }
70 return points;
69 return points;
@@ -73,14 +72,17 QVector<qreal> ChartBarCategoryAxisY::calculateLayout() const
73 QStringList ChartBarCategoryAxisY::createCategoryLabels(const QVector<qreal>& layout) const
72 QStringList ChartBarCategoryAxisY::createCategoryLabels(const QVector<qreal>& layout) const
74 {
73 {
75 QStringList result;
74 QStringList result;
76 QRectF rect = presenter()->chartsGeometry();
75
77 qreal d = (m_max - m_min) / rect.height();
76 qreal d = (m_max - m_min)/m_gridRect.height();
78 for (int i = 0; i < layout.count() - 1; ++i) {
77 for (int i = 0;i < layout.count()-1; ++i) {
79 qreal x = qFloor(((rect.height() - (layout[i + 1] + layout[i]) / 2 + rect.top()) * d + m_min + 0.5));
78 qreal x = qFloor(((m_gridRect.height()- (layout[i+1] + layout[i])/2 + m_gridRect.top())*d + m_min+0.5));
80 if ((x < m_categoriesAxis->categories().count()) && (x >= 0))
79 if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
81 result << m_categoriesAxis->categories().at(x);
80 result << m_categoriesAxis->categories().at(x);
82 else
81 }
83 result << ""; // No label for x coordinate
82 else {
83 // No label for x coordinate
84 result << "";
85 }
84 }
86 }
85 result << "";
87 result << "";
86 return result;
88 return result;
@@ -90,8 +92,7 void ChartBarCategoryAxisY::updateGeometry()
90 {
92 {
91 const QVector<qreal>& layout = ChartAxis::layout();
93 const QVector<qreal>& layout = ChartAxis::layout();
92
94
93 if (layout.isEmpty())
95 if(layout.isEmpty()) return;
94 return;
95
96
96 QStringList ticksList = createCategoryLabels(layout);
97 QStringList ticksList = createCategoryLabels(layout);
97
98
@@ -103,52 +104,55 void ChartBarCategoryAxisY::updateGeometry()
103 Q_ASSERT(labels.size() == ticksList.size());
104 Q_ASSERT(labels.size() == ticksList.size());
104 Q_ASSERT(layout.size() == ticksList.size());
105 Q_ASSERT(layout.size() == ticksList.size());
105
106
106 QRectF chartRect = presenter()->chartsGeometry();
107 const qreal delta = m_gridRect.height()/(m_categoriesAxis->d_ptr->count());
107
108 const qreal delta = chartRect.height() / (m_categoriesAxis->d_ptr->count());
109
108
110 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
109 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
111 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
110 lineItem->setLine(m_gridRect.left() , m_gridRect.top(), m_gridRect.left(), m_gridRect.bottom());
112
111
113 qreal height = chartRect.bottom();
112 qreal height = m_gridRect.bottom();
114 for (int i = 0; i < layout.size(); ++i) {
113 for (int i = 0; i < layout.size(); ++i) {
115 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
114 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
116 lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
115 lineItem->setLine(m_gridRect.left() , layout[i], m_gridRect.right(), layout[i]);
117 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
116 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
118 labelItem->setText(ticksList.at(i));
117 labelItem->setText(ticksList.at(i));
119 const QRectF &rect = labelItem->boundingRect();
118 const QRectF& rect = labelItem->boundingRect();
120 QPointF center = rect.center();
119 QPointF center = rect.center();
121 labelItem->setTransformOriginPoint(center.x(), center.y());
120 labelItem->setTransformOriginPoint(center.x(), center.y());
122
121
123 if (i == 0)
122 if(i==0) {
124 labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i + 1] + (delta) / 2 - center.y());
123 labelItem->setPos(m_gridRect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
125 else
124 }
126 labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] - (delta) / 2 - center.y());
125 else {
126 labelItem->setPos(m_gridRect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
127 }
127
128
128 if (labelItem->pos().y() + rect.height() >= height || labelItem->pos().y() < chartRect.top()) {
129 if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_gridRect.top()) {
129 labelItem->setVisible(false);
130 labelItem->setVisible(false);
130 } else {
131 }
132 else {
131 labelItem->setVisible(true);
133 labelItem->setVisible(true);
132 height = labelItem->pos().y();
134 height=labelItem->pos().y();
133 }
135 }
134
136
135 if ((i + 1) % 2 && i > 1) {
137 if ((i+1)%2 && i>1) {
136 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
138 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
137 rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
139 rectItem->setRect(m_gridRect.left(),layout[i],m_gridRect.width(),layout[i-1]-layout[i]);
138 }
140 }
139 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
141 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
140 lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]);
142 lineItem->setLine(m_gridRect.left()-5,layout[i],m_gridRect.left(),layout[i]);
141 }
143 }
142 }
144 }
143
145
144 void ChartBarCategoryAxisY::handleAxisUpdated()
146 void ChartBarCategoryAxisY::handleAxisUpdated()
145 {
147 {
146
148
147 if (m_categoriesAxis->categories() != m_categories) {
149 if(m_categoriesAxis->categories()!=m_categories)
150 {
148 m_categories = m_categoriesAxis->categories();
151 m_categories=m_categoriesAxis->categories();
149 if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
152 if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) {
150 updateGeometry();
153 updateGeometry();
151 }
154 }
155 }
152 ChartAxis::handleAxisUpdated();
156 ChartAxis::handleAxisUpdated();
153 }
157 }
154
158
@@ -171,8 +175,10 QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constra
171 height = qMax(height, base.height());
175 height=qMax(height,base.height());
172 sh = QSizeF(width, height);
176 sh = QSizeF(width,height);
173 break;
177 break;
174 case Qt::PreferredSize:
178 case Qt::PreferredSize:{
175 for (int i = 0; i < ticksList.size(); ++i) {
179
180 for (int i = 0; i < ticksList.size(); ++i)
181 {
176 QRectF rect = fn.boundingRect(ticksList.at(i));
182 QRectF rect = fn.boundingRect(ticksList.at(i));
177 height += rect.height();
183 height+=rect.height();
178 width = qMax(rect.width() + label_padding, width);
184 width=qMax(rect.width()+label_padding,width);
@@ -181,6 +187,7 QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constra
181 width += base.width();
187 width+=base.width();
182 sh = QSizeF(width, height);
188 sh = QSizeF(width,height);
183 break;
189 break;
190 }
184 default:
191 default:
185 break;
192 break;
186 }
193 }
Show file before | Show file after | Hide comments
@@ -30,8 +30,7 static int label_padding = 5;
30
30
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32
32
33 ChartCategoryAxisX::ChartCategoryAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
33 ChartCategoryAxisX::ChartCategoryAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
34 : ChartAxis(axis, presenter)
35 {
34 {
36 }
35 }
37
36
@@ -48,18 +47,16 QVector<qreal> ChartCategoryAxisX::calculateLayout() const
48 if (tickCount < 2)
47 if (tickCount < 2)
49 return points;
48 return points;
50
49
51 QRectF rect = presenter()->chartsGeometry();
52
53 qreal range = axis->max() - axis->min();
50 qreal range = axis->max() - axis->min();
54 if (range > 0) {
51 if (range > 0) {
55 points.resize(tickCount);
52 points.resize(tickCount);
56 qreal scale = rect.width() / range;
53 qreal scale = m_gridRect.width() / range;
57 for (int i = 0; i < tickCount; ++i)
54 for (int i = 0; i < tickCount; ++i)
58 if (i < tickCount - 1) {
55 if (i < tickCount - 1) {
59 int x = (axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.left();
56 int x = (axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + m_gridRect.left();
60 points[i] = x;
57 points[i] = x;
61 } else {
58 } else {
62 int x = (axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min()) * scale + rect.left();
59 int x = (axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min()) * scale + m_gridRect.left();
63 points[i] = x;
60 points[i] = x;
64 }
61 }
65 }
62 }
@@ -70,8 +67,7 void ChartCategoryAxisX::updateGeometry()
70 {
67 {
71 const QVector<qreal>& layout = ChartAxis::layout();
68 const QVector<qreal>& layout = ChartAxis::layout();
72
69
73 if (layout.isEmpty())
70 if(layout.isEmpty()) return;
74 return;
75
71
76 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
72 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
77 QStringList ticksList = categoryAxis->categoriesLabels();
73 QStringList ticksList = categoryAxis->categoriesLabels();
@@ -82,58 +78,61 void ChartCategoryAxisX::updateGeometry()
82 QList<QGraphicsItem *> axis = m_arrow->childItems();
78 QList<QGraphicsItem *> axis = m_arrow->childItems();
83
79
84
80
85 for (int i = 0; i < labels.count(); i++)
81 for (int i = 0; i < labels.count(); i++) {
86 labels.at(i)->setVisible(false);
82 labels.at(i)->setVisible(false);
87
83 }
88 QRectF chartRect = presenter()->chartsGeometry();
89 // axis base line
84 // axis base line
90
85
91 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
86 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
92 lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
87 lineItem->setLine(m_gridRect.left(), m_gridRect.bottom(), m_gridRect.right(), m_gridRect.bottom());
93
88
94 for (int i = 0; i < layout.size(); ++i) {
89 for (int i = 0; i < layout.size(); ++i) {
95
90
96 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
91 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
97 if (i < ticksList.count())
92 if (i < ticksList.count()) {
98 labelItem->setText(ticksList.at(i));
93 labelItem->setText(ticksList.at(i));
94 }
99 const QRectF &rect = labelItem->boundingRect();
95 const QRectF& rect = labelItem->boundingRect();
100 QPointF center = rect.center();
96 QPointF center = rect.center();
101 labelItem->setTransformOriginPoint(center.x(), center.y());
97 labelItem->setTransformOriginPoint(center.x(), center.y());
102
98
103 if (i < layout.size() - 1)
99 if (i < layout.size() - 1) {
104 labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), chartRect.bottom() + label_padding);
100 labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), m_gridRect.bottom() + label_padding);
105 else
101 } else {
106 labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
102 labelItem->setPos(layout[i] - center.x(), m_gridRect.bottom() + label_padding);
103 }
107
104
108 // check if the label should be shown
105 // check if the label should be shown
109 if (labelItem->pos().x() + center.x() < chartRect.left() || labelItem->pos().x() + center.x() > chartRect.right())
106 if (labelItem->pos().x() + center.x() < m_gridRect.left() || labelItem->pos().x() + center.x() > m_gridRect.right())
110 labelItem->setVisible(false);
107 labelItem->setVisible(false);
111 else
108 else
112 labelItem->setVisible(true);
109 labelItem->setVisible(true);
113
110
114 if ((i + 1) % 2 && i > 1) {
111 if ((i + 1) % 2 && i > 1) {
115 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
112 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());
113 rectItem->setRect(layout[i - 1],m_gridRect.top(),layout[i]-layout[i - 1],m_gridRect.height());
117 }
114 }
118
115
119 // grid lines and axis line ticks
116 // grid lines and axis line ticks
120 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
117 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
121 lineItem->setPos(layout[i], chartRect.top());
118 lineItem->setPos(layout[i], m_gridRect.top());
122 lineItem->setLine(0, 0, 0, chartRect.height());
119 lineItem->setLine(0, 0, 0, m_gridRect.height());
123
120
124 QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
121 QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
125 tickLineItem->setPos(layout[i], chartRect.bottom());
122 tickLineItem->setPos(layout[i], m_gridRect.bottom());
126 tickLineItem->setLine(0, 0, 0, 5);
123 tickLineItem->setLine(0, 0, 0, 5);
127
124
128 // check if the grid line and the axis tick should be shown
125 // check if the grid line and the axis tick should be shown
129 if (lineItem->pos().x() < chartRect.left() || lineItem->pos().x() > chartRect.right()) {
126 if (lineItem->pos().x() < m_gridRect.left() || lineItem->pos().x() > m_gridRect.right()) {
130 lineItem->setVisible(false);
127 lineItem->setVisible(false);
131 tickLineItem->setVisible(false);
128 tickLineItem->setVisible(false);
132 } else {
129 } else {
133 lineItem->setVisible(true);
130 lineItem->setVisible(true);
134 tickLineItem->setVisible(true);
131 tickLineItem->setVisible(true);
135 }
132 }
133
136 }
134 }
135
137 }
136 }
138
137
139 void ChartCategoryAxisX::handleAxisUpdated()
138 void ChartCategoryAxisX::handleAxisUpdated()
@@ -161,8 +160,10 QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint
161 height += base.height();
160 height+=base.height();
162 sh = QSizeF(width, height);
161 sh = QSizeF(width,height);
163 break;
162 break;
164 case Qt::PreferredSize:
163 case Qt::PreferredSize: {
165 for (int i = 0; i < ticksList.size(); ++i) {
164
165 for (int i = 0; i < ticksList.size(); ++i)
166 {
166 QRectF rect = fn.boundingRect(ticksList.at(i));
167 QRectF rect = fn.boundingRect(ticksList.at(i));
167 width += rect.width();
168 width+=rect.width();
168 height = qMax(rect.height() + label_padding, height);
169 height=qMax(rect.height()+label_padding,height);
@@ -171,6 +172,7 QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint
171 height += base.height();
172 height+=base.height();
172 sh = QSizeF(width, height);
173 sh = QSizeF(width,height);
173 break;
174 break;
175 }
174 default:
176 default:
175 break;
177 break;
176 }
178 }
Show file before | Show file after | Hide comments
@@ -30,8 +30,7 static int label_padding = 5;
30
30
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32
32
33 ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
33 ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
34 : ChartAxis(axis, presenter)
35 {
34 {
36 }
35 }
37
36
@@ -48,22 +47,19 QVector<qreal> ChartCategoryAxisY::calculateLayout() const
48 if (tickCount < 2)
47 if (tickCount < 2)
49 return points;
48 return points;
50
49
51 QRectF rect = presenter()->chartsGeometry();
52
53 qreal range = axis->max() - axis->min();
50 qreal range = axis->max() - axis->min();
54 if (range > 0) {
51 if (range > 0) {
55 points.resize(tickCount);
52 points.resize(tickCount);
56 qreal scale = rect.height() / range;
53 qreal scale = m_gridRect.height() / range;
57 for (int i = 0; i < tickCount; ++i) {
54 for (int i = 0; i < tickCount; ++i)
58 if (i < tickCount - 1) {
55 if (i < tickCount - 1) {
59 int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.bottom();
56 int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + m_gridRect.bottom();
60 points[i] = y;
57 points[i] = y;
61 } else {
58 } else {
62 int y = -(axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min()) * scale + rect.bottom();
59 int y = -(axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min()) * scale + m_gridRect.bottom();
63 points[i] = y;
60 points[i] = y;
64 }
61 }
65 }
62 }
66 }
67
63
68 return points;
64 return points;
69 }
65 }
@@ -72,8 +68,9 void ChartCategoryAxisY::updateGeometry()
72 {
68 {
73 const QVector<qreal> &layout = ChartAxis::layout();
69 const QVector<qreal> &layout = ChartAxis::layout();
74
70
75 if (layout.isEmpty())
71 if(layout.isEmpty()) {
76 return;
72 return;
73 }
77
74
78 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
75 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
79 QStringList ticksList = categoryAxis->categoriesLabels();
76 QStringList ticksList = categoryAxis->categoriesLabels();
@@ -87,11 +84,9 void ChartCategoryAxisY::updateGeometry()
87 labels.at(i)->setVisible(false);
84 labels.at(i)->setVisible(false);
88 }
85 }
89
86
90 QRectF chartRect = presenter()->chartsGeometry();
91
92 // axis base line
87 // axis base line
93 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
88 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
94 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
89 lineItem->setLine(m_gridRect.left() , m_gridRect.top(), m_gridRect.left(), m_gridRect.bottom());
95
90
96 for (int i = 0; i < layout.size(); ++i) {
91 for (int i = 0; i < layout.size(); ++i) {
97
92
@@ -107,39 +102,41 void ChartCategoryAxisY::updateGeometry()
107
102
108
103
109 if (i < layout.size() - 1)
104 if (i < layout.size() - 1)
110 labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
105 labelItem->setPos(m_gridRect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
111 else
106 else
112 labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] - center.y());
107 labelItem->setPos(m_gridRect.left() - rect.width() - label_padding , layout[i]-center.y());
113
108
114 // check if the label should be shown
109 // check if the label should be shown
115 if (labelItem->pos().y() + center.y() < chartRect.top() || labelItem->pos().y() + center.y() > chartRect.bottom())
110 if (labelItem->pos().y() + center.y() < m_gridRect.top() || labelItem->pos().y() + center.y() > m_gridRect.bottom())
116 labelItem->setVisible(false);
111 labelItem->setVisible(false);
117 else
112 else
118 labelItem->setVisible(true);
113 labelItem->setVisible(true);
119
114
120 if ((i + 1) % 2 && i > 1) {
115 if ((i+1)%2 && i>1) {
121 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
116 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
122 rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
117 rectItem->setRect(m_gridRect.left(),layout[i],m_gridRect.width(),layout[i-1]-layout[i]);
123 }
118 }
124
119
125 // grid lines and axis line ticks
120 // grid lines and axis line ticks
126 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
121 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
127 lineItem->setPos(chartRect.left(), layout[i]);
122 lineItem->setPos(m_gridRect.left(), layout[i]);
128 lineItem->setLine(0, 0, chartRect.width(), 0);
123 lineItem->setLine(0, 0, m_gridRect.width(), 0);
129
124
130 QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
125 QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
131 tickLineItem->setPos(chartRect.left(), layout[i]);
126 tickLineItem->setPos(m_gridRect.left(), layout[i]);
132 tickLineItem->setLine(-5, 0, 0, 0);
127 tickLineItem->setLine(-5, 0, 0, 0);
133
128
134 // check if the grid line and the axis tick should be shown
129 // check if the grid line and the axis tick should be shown
135 if (lineItem->pos().y() < chartRect.top() || lineItem->pos().y() > chartRect.bottom()) {
130 if (lineItem->pos().y() < m_gridRect.top() || lineItem->pos().y() > m_gridRect.bottom()) {
136 lineItem->setVisible(false);
131 lineItem->setVisible(false);
137 tickLineItem->setVisible(false);
132 tickLineItem->setVisible(false);
138 } else {
133 } else {
139 lineItem->setVisible(true);
134 lineItem->setVisible(true);
140 tickLineItem->setVisible(true);
135 tickLineItem->setVisible(true);
141 }
136 }
137
142 }
138 }
139
143 }
140 }
144
141
145 void ChartCategoryAxisY::handleAxisUpdated()
142 void ChartCategoryAxisY::handleAxisUpdated()
@@ -167,8 +164,10 QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint
167 height += base.height();
164 height+=base.height();
168 sh = QSizeF(width, height);
165 sh = QSizeF(width,height);
169 break;
166 break;
170 case Qt::PreferredSize:
167 case Qt::PreferredSize:{
171 for (int i = 0; i < ticksList.size(); ++i) {
168
169 for (int i = 0; i < ticksList.size(); ++i)
170 {
172 QRectF rect = fn.boundingRect(ticksList.at(i));
171 QRectF rect = fn.boundingRect(ticksList.at(i));
173 height += rect.height();
172 height+=rect.height();
174 width = qMax(rect.width() + label_padding, width);
173 width=qMax(rect.width()+label_padding,width);
@@ -177,6 +176,7 QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint
177 width += base.width();
176 width+=base.width();
178 sh = QSizeF(width, height);
177 sh = QSizeF(width,height);
179 break;
178 break;
179 }
180 default:
180 default:
181 break;
181 break;
182 }
182 }
Show file before | Show file after | Hide comments
@@ -22,6 +22,7
22 #include "qabstractaxis.h"
22 #include "qabstractaxis.h"
23 #include "qabstractaxis_p.h"
23 #include "qabstractaxis_p.h"
24 #include "chartpresenter_p.h"
24 #include "chartpresenter_p.h"
25 #include "chartlayout_p.h"
25 #include "domain_p.h"
26 #include "domain_p.h"
26 #include <qmath.h>
27 #include <qmath.h>
27 #include <QDateTime>
28 #include <QDateTime>
@@ -31,8 +32,7
31
32
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
34
34 ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter)
35 ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : ChartElement(presenter),
35 : ChartElement(presenter),
36 m_chartAxis(axis),
36 m_chartAxis(axis),
37 m_labelsAngle(0),
37 m_labelsAngle(0),
38 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
38 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
@@ -42,7 +42,8 ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter)
42 m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
42 m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
43 m_min(0),
43 m_min(0),
44 m_max(0),
44 m_max(0),
45 m_animation(0)
45 m_animation(0),
46 m_labelPadding(5)
46 {
47 {
47 //initial initialization
48 //initial initialization
48 m_arrow->setZValue(ChartPresenter::AxisZValue);
49 m_arrow->setZValue(ChartPresenter::AxisZValue);
@@ -76,13 +77,11 void ChartAxis::createItems(int count)
76 {
77 {
77 if (m_arrow->children().size() == 0)
78 if (m_arrow->children().size() == 0)
78 m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
79 m_arrow->addToGroup(new AxisItem(this,presenter()->rootItem()));
79
80 for (int i = 0; i < count; ++i) {
80 for (int i = 0; i < count; ++i) {
81 m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
81 m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
82 m_labels->addToGroup(new QGraphicsSimpleTextItem(presenter()->rootItem()));
82 m_labels->addToGroup(new QGraphicsSimpleTextItem(presenter()->rootItem()));
83 m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
83 m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
84 if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
84 if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
85 m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
86 }
85 }
87 }
86 }
88
87
@@ -94,8 +93,7 void ChartAxis::deleteItems(int count)
94 QList<QGraphicsItem *> axis = m_arrow->childItems();
93 QList<QGraphicsItem *> axis = m_arrow->childItems();
95
94
96 for (int i = 0; i < count; ++i) {
95 for (int i = 0; i < count; ++i) {
97 if (lines.size() % 2 && lines.size() > 1)
96 if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
98 delete(shades.takeLast());
99 delete(lines.takeLast());
97 delete(lines.takeLast());
100 delete(labels.takeLast());
98 delete(labels.takeLast());
101 delete(axis.takeLast());
99 delete(axis.takeLast());
@@ -106,13 +104,14 void ChartAxis::updateLayout(QVector<qreal> &layout)
106 {
104 {
107 int diff = m_layoutVector.size() - layout.size();
105 int diff = m_layoutVector.size() - layout.size();
108
106
109 if (diff > 0)
107 if (diff>0) {
110 deleteItems(diff);
108 deleteItems(diff);
111 else if (diff < 0)
109 }
110 else if (diff<0) {
112 createItems(-diff);
111 createItems(-diff);
112 }
113
113
114 if (diff < 0)
114 if(diff<0) handleAxisUpdated();
115 handleAxisUpdated();
116
115
117 if (m_animation) {
116 if (m_animation) {
118 switch (presenter()->state()) {
117 switch(presenter()->state()){
@@ -138,7 +137,8 void ChartAxis::updateLayout(QVector<qreal> &layout)
138 }
137 }
139 m_animation->setValues(m_layoutVector, layout);
138 m_animation->setValues(m_layoutVector,layout);
140 presenter()->startAnimation(m_animation);
139 presenter()->startAnimation(m_animation);
141 } else {
140 }
141 else {
142 setLayout(layout);
142 setLayout(layout);
143 updateGeometry();
143 updateGeometry();
144 }
144 }
@@ -206,67 +206,79 void ChartAxis::setShadesVisibility(bool visible)
206
206
207 void ChartAxis::setLabelsAngle(int angle)
207 void ChartAxis::setLabelsAngle(int angle)
208 {
208 {
209 foreach (QGraphicsItem *item , m_labels->childItems())
209 foreach(QGraphicsItem* item , m_labels->childItems()) {
210 item->setRotation(angle);
210 item->setRotation(angle);
211 }
211
212
212 m_labelsAngle = angle;
213 m_labelsAngle=angle;
213 }
214 }
214
215
215 void ChartAxis::setLabelsPen(const QPen &pen)
216 void ChartAxis::setLabelsPen(const QPen &pen)
216 {
217 {
217 foreach (QGraphicsItem *item , m_labels->childItems())
218 foreach(QGraphicsItem* item , m_labels->childItems()) {
218 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
219 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
219 }
220 }
221 }
220
222
221 void ChartAxis::setLabelsBrush(const QBrush &brush)
223 void ChartAxis::setLabelsBrush(const QBrush &brush)
222 {
224 {
223 foreach (QGraphicsItem *item , m_labels->childItems())
225 foreach(QGraphicsItem* item , m_labels->childItems()) {
224 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
226 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
225 }
227 }
228 }
226
229
227 void ChartAxis::setLabelsFont(const QFont &font)
230 void ChartAxis::setLabelsFont(const QFont &font)
228 {
231 {
229 foreach (QGraphicsItem *item , m_labels->childItems())
232 foreach(QGraphicsItem* item , m_labels->childItems()) {
230 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
233 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
231
234 }
232 if (m_font != font) {
235 if(m_font!=font) {
233 m_font = font;
236 m_font = font;
234 foreach (QGraphicsItem *item , m_labels->childItems())
237 foreach(QGraphicsItem* item , m_labels->childItems()) {
235 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
238 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
239 }
236 QGraphicsLayoutItem::updateGeometry();
240 QGraphicsLayoutItem::updateGeometry();
237 presenter()->layout()->invalidate();
241 presenter()->layout()->invalidate();
242
238 }
243 }
239 }
244 }
240
245
241 void ChartAxis::setShadesBrush(const QBrush &brush)
246 void ChartAxis::setShadesBrush(const QBrush &brush)
242 {
247 {
243 foreach (QGraphicsItem *item , m_shades->childItems())
248 foreach(QGraphicsItem* item , m_shades->childItems()) {
244 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
249 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
245 }
250 }
251 }
246
252
247 void ChartAxis::setShadesPen(const QPen &pen)
253 void ChartAxis::setShadesPen(const QPen &pen)
248 {
254 {
249 foreach (QGraphicsItem *item , m_shades->childItems())
255 foreach(QGraphicsItem* item , m_shades->childItems()) {
250 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
256 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
251 }
257 }
258 }
252
259
253 void ChartAxis::setArrowPen(const QPen &pen)
260 void ChartAxis::setArrowPen(const QPen &pen)
254 {
261 {
255 foreach (QGraphicsItem *item , m_arrow->childItems())
262 foreach(QGraphicsItem* item , m_arrow->childItems()) {
256 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
263 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
257 }
264 }
265 }
258
266
259 void ChartAxis::setGridPen(const QPen &pen)
267 void ChartAxis::setGridPen(const QPen &pen)
260 {
268 {
261 foreach (QGraphicsItem *item , m_grid->childItems())
269 foreach(QGraphicsItem* item , m_grid->childItems()) {
262 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
270 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
263 }
271 }
272 }
273
274 void ChartAxis::setLabelPadding(int padding)
275 {
276 m_labelPadding=padding;
277 }
264
278
265 bool ChartAxis::isEmpty()
279 bool ChartAxis::isEmpty()
266 {
280 {
267 return !m_rect.isValid() ||
281 return !m_axisRect.isValid() || m_gridRect.isEmpty() || qFuzzyIsNull(m_min - m_max);
268 presenter()->chartsGeometry().isEmpty() ||
269 qFuzzyIsNull(m_min - m_max);
270 }
282 }
271
283
272 void ChartAxis::handleDomainUpdated()
284 void ChartAxis::handleDomainUpdated()
@@ -278,12 +290,15 void ChartAxis::handleDomainUpdated()
278 if (m_chartAxis->orientation() == Qt::Horizontal) {
290 if(m_chartAxis->orientation()==Qt::Horizontal) {
279 min = domain->minX();
291 min = domain->minX();
280 max = domain->maxX();
292 max = domain->maxX();
281 } else if (m_chartAxis->orientation() == Qt::Vertical) {
293 }
294 else if (m_chartAxis->orientation()==Qt::Vertical)
295 {
282 min = domain->minY();
296 min = domain->minY();
283 max = domain->maxY();
297 max = domain->maxY();
284 }
298 }
285
299
286 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
300 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max))
301 {
287 m_min = min;
302 m_min = min;
288 m_max = max;
303 m_max = max;
289
304
@@ -308,8 +323,8 void ChartAxis::handleDomainUpdated()
308
323
309 void ChartAxis::handleAxisUpdated()
324 void ChartAxis::handleAxisUpdated()
310 {
325 {
311 if (isEmpty())
326 if(isEmpty()) return;
312 return;
327
313
328
314 bool visible = m_chartAxis->isVisible();
329 bool visible = m_chartAxis->isVisible();
315
330
@@ -332,7 +347,7 void ChartAxis::setTitleText(const QString &title)
332 {
347 {
333 if (m_titleText != title) {
348 if(m_titleText!=title) {
334 m_titleText = title;
349 m_titleText = title;
335 m_rect = QRect();
350 m_axisRect = QRect();
336 QGraphicsLayoutItem::updateGeometry();
351 QGraphicsLayoutItem::updateGeometry();
337 presenter()->layout()->invalidate();
352 presenter()->layout()->invalidate();
338 }
353 }
@@ -346,51 +361,47 void ChartAxis::hide()
346 setShadesVisibility(false);
361 setShadesVisibility(false);
347 }
362 }
348
363
349 void ChartAxis::setGeometry(const QRectF &rect)
364 void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
350 {
365 {
351 m_rect = rect;
366 m_gridRect = grid;
367 m_axisRect = axis;
352
368
353 if (isEmpty())
369 if (isEmpty()) return;
354 return;
355
370
356 if (!m_titleText.isNull()) {
371 if(!m_titleText.isNull()) {
357 QFontMetrics fn(m_title->font());
372 QFontMetrics fn(m_title->font());
358
373
359 int size(0);
374 int size(0);
360
375
361 QRectF chartRect = presenter()->chartsGeometry();
362
363 if (orientation() == Qt::Horizontal)
376 if(orientation()==Qt::Horizontal)
364 size = chartRect.width();
377 size = grid.width();
365 else if (orientation() == Qt::Vertical)
378 else if(orientation()==Qt::Vertical)
366 size = chartRect.height();
379 size = grid.height();
367
380
368 if (fn.boundingRect(m_titleText).width() > size) {
381 if (fn.boundingRect(m_titleText).width() > size)
382 {
369 QString string = m_titleText + "...";
383 QString string = m_titleText + "...";
370 while (fn.boundingRect(string).width() > size && string.length() > 3)
384 while (fn.boundingRect(string).width() > size && string.length() > 3)
371 string.remove(string.length() - 4, 1);
385 string.remove(string.length() - 4, 1);
372 m_title->setText(string);
386 m_title->setText(string);
373 } else {
374 m_title->setText(m_titleText);
375 }
387 }
388 else
389 m_title->setText(m_titleText);
376
390
377 QPointF center = chartRect.center() - m_title->boundingRect().center();
391 QPointF center = grid.center() - m_title->boundingRect().center();
378 if (orientation() == Qt::Horizontal) {
392 if(orientation()==Qt::Horizontal) {
379 m_title->setPos(center.x(), m_rect.bottom() - m_title->boundingRect().height());
393 m_title->setPos(center.x(),m_axisRect.bottom()-m_title->boundingRect().height());
380 } else if (orientation() == Qt::Vertical) {
394 }
395 else if(orientation()==Qt::Vertical) {
381 m_title->setTransformOriginPoint(m_title->boundingRect().center());
396 m_title->setTransformOriginPoint(m_title->boundingRect().center());
382 m_title->setRotation(270);
397 m_title->setRotation(270);
383 m_title->setPos(m_rect.left() - m_title->boundingRect().width() / 2 + m_title->boundingRect().height() / 2, center.y());
398 m_title->setPos(m_axisRect.left()- m_title->boundingRect().width()/2+m_title->boundingRect().height()/2,center.y());
384 }
399 }
385 }
400 }
386
401
387 QVector<qreal> layout = calculateLayout();
402 QVector<qreal> layout = calculateLayout();
388 updateLayout(layout);
403 updateLayout(layout);
389 }
390
404
391 void ChartAxis::setInternalRect(const QRectF &size)
392 {
393 m_internalRect = size;
394 }
405 }
395
406
396 void ChartAxis::axisSelected()
407 void ChartAxis::axisSelected()
@@ -418,7 +429,8 QStringList ChartAxis::createNumberLabels(qreal min, qreal max, int ticks) const
418 qreal value = min + (i * (max - min) / (ticks - 1));
429 qreal value = min + (i * (max - min)/ (ticks-1));
419 labels << QString::number(value, 'f', n);
430 labels << QString::number(value,'f',n);
420 }
431 }
421 } else {
432 }
433 else {
422 QByteArray array = format.toAscii();
434 QByteArray array = format.toAscii();
423 for (int i = 0; i < ticks; i++) {
435 for (int i=0; i< ticks; i++) {
424 qreal value = min + (i * (max - min) / (ticks - 1));
436 qreal value = min + (i * (max - min)/ (ticks-1));
@@ -434,9 +446,9 Qt::Orientation ChartAxis::orientation() const
434 return m_chartAxis->orientation();
446 return m_chartAxis->orientation();
435 }
447 }
436
448
437 bool ChartAxis::alternativePlacement() const
449 Qt::Alignment ChartAxis::alignment() const
438 {
450 {
439 return m_chartAxis->alternativePlacement();
451 return m_chartAxis->alignment();
440 }
452 }
441
453
442 bool ChartAxis::isVisible()
454 bool ChartAxis::isVisible()
@@ -446,26 +458,32 bool ChartAxis::isVisible()
446
458
447 QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
459 QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
448 {
460 {
461
449 Q_UNUSED(constraint);
462 Q_UNUSED(constraint);
450 QFontMetrics fn(m_title->font());
463 QFontMetrics fn(m_title->font());
451 QSizeF sh;
464 QSizeF sh;
452
465
453 if (m_titleText.isNull())
466 if(m_titleText.isNull()) return sh;
454 return sh;
455
467
456 switch (which) {
468 switch(which) {
457 case Qt::MinimumSize:
469 case Qt::MinimumSize:
458 if (orientation() == Qt::Horizontal)
470 if(orientation()==Qt::Horizontal) {
459 sh = QSizeF(fn.boundingRect("...").width(), fn.height());
471 sh = QSizeF(fn.boundingRect ("...").width(),fn.height());
460 else if (orientation() == Qt::Vertical)
472 }
473 else if(orientation()==Qt::Vertical) {
461 sh = QSizeF(fn.height(), fn.boundingRect("...").width());
474 sh = QSizeF(fn.height(),fn.boundingRect ("...").width());
475 }
476
462 break;
477 break;
463 case Qt::MaximumSize:
478 case Qt::MaximumSize:
464 case Qt::PreferredSize:
479 case Qt::PreferredSize:
465 if (orientation() == Qt::Horizontal)
480 if(orientation()==Qt::Horizontal) {
466 sh = QSizeF(fn.boundingRect(m_chartAxis->title()).width(), fn.height());
481 sh = QSizeF(fn.boundingRect(m_chartAxis->title()).width(),fn.height());
467 else if (orientation() == Qt::Vertical)
482 }
483 else if(orientation()==Qt::Vertical) {
468 sh = QSizeF(fn.height(), fn.boundingRect(m_chartAxis->title()).width());
484 sh = QSizeF(fn.height(),fn.boundingRect(m_chartAxis->title()).width());
485 }
486
469 break;
487 break;
470 default:
488 default:
471 break;
489 break;
Show file before | Show file after | Hide comments
@@ -82,13 +82,14 public:
82 void setLabelsPen(const QPen &pen);
82 void setLabelsPen(const QPen &pen);
83 void setLabelsBrush(const QBrush &brush);
83 void setLabelsBrush(const QBrush &brush);
84 void setLabelsFont(const QFont &font);
84 void setLabelsFont(const QFont &font);
85 void setLabelPadding(int padding);
86 int labelPadding() const { return m_labelPadding;};
85
87
86 void setTitlePen(const QPen &pen);
88 void setTitlePen(const QPen &pen);
87 void setTitleBrush(const QBrush &brush);
89 void setTitleBrush(const QBrush &brush);
88 void setTitleFont(const QFont &font);
90 void setTitleFont(const QFont &font);
89 void setTitleText(const QString &title);
91 void setTitleText(const QString &title);
90
92
91
92 void setLayout(QVector<qreal> &layout);
93 void setLayout(QVector<qreal> &layout);
93 QVector<qreal> layout() const { return m_layoutVector; }
94 QVector<qreal> layout() const { return m_layoutVector; }
94
95
@@ -96,19 +97,19 public:
96 ChartAnimation *animation() const { return m_animation; };
97 ChartAnimation *animation() const { return m_animation; };
97
98
98 Qt::Orientation orientation() const;
99 Qt::Orientation orientation() const;
99 bool alternativePlacement() const;
100 Qt::Alignment alignment() const;
100
101
101 bool isVisible();
102 bool isVisible();
102 void hide();
103 void hide();
103
104
104 void setGeometry(const QRectF &size);
105 void setGeometry(const QRectF &axis, const QRectF &grid);
105 QRectF geometry() const { return m_rect; }
106 QRectF axisGeometry() const { return m_axisRect; }
106
107 QRectF gridGeometry() const { return m_gridRect; }
107 void setInternalRect(const QRectF &size);
108
108
109 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
109 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
110
110
111 protected:
111 protected:
112 void setGeometry(const QRectF &size){ Q_UNUSED(size);};
112 virtual void updateGeometry() = 0;
113 virtual void updateGeometry() = 0;
113 virtual QVector<qreal> calculateLayout() const = 0;
114 virtual QVector<qreal> calculateLayout() const = 0;
114 QStringList createNumberLabels(qreal min, qreal max, int ticks) const;
115 QStringList createNumberLabels(qreal min, qreal max, int ticks) const;
@@ -130,8 +131,8 protected:
130 QAbstractAxis *m_chartAxis;
131 QAbstractAxis *m_chartAxis;
131 int m_labelsAngle;
132 int m_labelsAngle;
132 //TODO: to be removed
133 //TODO: to be removed
133 QRectF m_rect;
134 QRectF m_axisRect;
134 QRectF m_internalRect;
135 QRectF m_gridRect;
135 QScopedPointer<QGraphicsItemGroup> m_grid;
136 QScopedPointer<QGraphicsItemGroup> m_grid;
136 QScopedPointer<QGraphicsItemGroup> m_shades;
137 QScopedPointer<QGraphicsItemGroup> m_shades;
137 QScopedPointer<QGraphicsItemGroup> m_labels;
138 QScopedPointer<QGraphicsItemGroup> m_labels;
@@ -143,6 +144,7 protected:
143 AxisAnimation *m_animation;
144 AxisAnimation *m_animation;
144 QFont m_font;
145 QFont m_font;
145 QString m_titleText;
146 QString m_titleText;
147 int m_labelPadding;
146
148
147 friend class AxisAnimation;
149 friend class AxisAnimation;
148 friend class AxisItem;
150 friend class AxisItem;
Show file before | Show file after | Hide comments
@@ -31,8 +31,7 static int label_padding = 5;
31
31
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
33
34 ChartDateTimeAxisX::ChartDateTimeAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
34 ChartDateTimeAxisX::ChartDateTimeAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
35 : ChartAxis(axis, presenter),
36 m_tickCount(0)
35 m_tickCount(0)
37 {
36 {
38 }
37 }
@@ -62,10 +61,10 QVector<qreal> ChartDateTimeAxisX::calculateLayout() const
62
61
63 QVector<qreal> points;
62 QVector<qreal> points;
64 points.resize(m_tickCount);
63 points.resize(m_tickCount);
65 QRectF rect = presenter()->chartsGeometry();
64
66 const qreal deltaX = rect.width() / (m_tickCount - 1);
65 const qreal deltaX = m_gridRect.width()/(m_tickCount-1);
67 for (int i = 0; i < m_tickCount; ++i) {
66 for (int i = 0; i < m_tickCount; ++i) {
68 int x = i * deltaX + rect.left();
67 int x = i * deltaX + m_gridRect.left();
69 points[i] = x;
68 points[i] = x;
70 }
69 }
71 return points;
70 return points;
@@ -75,8 +74,7 void ChartDateTimeAxisX::updateGeometry()
75 {
74 {
76 const QVector<qreal>& layout = ChartAxis::layout();
75 const QVector<qreal>& layout = ChartAxis::layout();
77
76
78 if (layout.isEmpty())
77 if(layout.isEmpty()) return;
79 return;
80
78
81 QStringList ticksList;
79 QStringList ticksList;
82
80
@@ -90,21 +88,19 void ChartDateTimeAxisX::updateGeometry()
90 Q_ASSERT(labels.size() == ticksList.size());
88 Q_ASSERT(labels.size() == ticksList.size());
91 Q_ASSERT(layout.size() == ticksList.size());
89 Q_ASSERT(layout.size() == ticksList.size());
92
90
93 QRectF chartRect = presenter()->chartsGeometry();
94
95 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
91 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
96 lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
92 lineItem->setLine(m_gridRect.left(), m_gridRect.bottom(), m_gridRect.right(), m_gridRect.bottom());
97
93
98 qreal width = 0;
94 qreal width = 0;
99 for (int i = 0; i < layout.size(); ++i) {
95 for (int i = 0; i < layout.size(); ++i) {
100 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
96 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
101 lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom());
97 lineItem->setLine(layout[i], m_gridRect.top(), layout[i], m_gridRect.bottom());
102 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
98 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
103 labelItem->setText(ticksList.at(i));
99 labelItem->setText(ticksList.at(i));
104 const QRectF &rect = labelItem->boundingRect();
100 const QRectF& rect = labelItem->boundingRect();
105 QPointF center = rect.center();
101 QPointF center = rect.center();
106 labelItem->setTransformOriginPoint(center.x(), center.y());
102 labelItem->setTransformOriginPoint(center.x(), center.y());
107 labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
103 labelItem->setPos(layout[i] - center.x(), m_gridRect.bottom() + label_padding);
108
104
109 if (labelItem->pos().x() <= width) {
105 if(labelItem->pos().x()<=width){
110 labelItem->setVisible(false);
106 labelItem->setVisible(false);
@@ -117,10 +113,10 void ChartDateTimeAxisX::updateGeometry()
117
113
118 if ((i + 1) % 2 && i > 1) {
114 if ((i+1)%2 && i>1) {
119 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
115 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());
116 rectItem->setRect(layout[i-1],m_gridRect.top(),layout[i]-layout[i-1],m_gridRect.height());
121 }
117 }
122 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
118 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
123 lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5);
119 lineItem->setLine(layout[i],m_gridRect.bottom(),layout[i],m_gridRect.bottom()+5);
124 }
120 }
125 }
121 }
126
122
@@ -144,13 +140,17 QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint
144 sh = QSizeF(fn.boundingRect("...").width(), fn.height());
140 sh = QSizeF(fn.boundingRect("...").width(),fn.height());
145 break;
141 break;
146 case Qt::PreferredSize: {
142 case Qt::PreferredSize:{
143
147 const QVector<qreal>& layout = ChartAxis::layout();
144 const QVector<qreal>& layout = ChartAxis::layout();
148 if (layout.isEmpty())
145 if(layout.isEmpty()) break;
149 break;
150 QStringList ticksList;
146 QStringList ticksList;
147
148
151 qreal width = 0;
149 qreal width=0;
152 qreal height = 0;
150 qreal height=0;
153 for (int i = 0; i < ticksList.size(); ++i) {
151
152 for (int i = 0; i < ticksList.size(); ++i)
153 {
154 QRectF rect = fn.boundingRect(ticksList.at(i));
154 QRectF rect = fn.boundingRect(ticksList.at(i));
155 width += rect.width();
155 width+=rect.width();
156 height += qMax(rect.height() + label_padding, height);
156 height+=qMax(rect.height()+label_padding,height);
Show file before | Show file after | Hide comments
@@ -31,8 +31,7 static int label_padding = 5;
31
31
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
33
34 ChartDateTimeAxisY::ChartDateTimeAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
34 ChartDateTimeAxisY::ChartDateTimeAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
35 : ChartAxis(axis, presenter),
36 m_tickCount(0)
35 m_tickCount(0)
37 {
36 {
38 }
37 }
@@ -62,10 +61,10 QVector<qreal> ChartDateTimeAxisY::calculateLayout() const
62
61
63 QVector<qreal> points;
62 QVector<qreal> points;
64 points.resize(m_tickCount);
63 points.resize(m_tickCount);
65 QRectF rect = presenter()->chartsGeometry();
64
66 const qreal deltaY = rect.height() / (m_tickCount - 1);
65 const qreal deltaY = m_gridRect.height()/(m_tickCount-1);
67 for (int i = 0; i < m_tickCount; ++i) {
66 for (int i = 0; i < m_tickCount; ++i) {
68 int y = i * -deltaY + rect.bottom();
67 int y = i * -deltaY + m_gridRect.bottom();
69 points[i] = y;
68 points[i] = y;
70 }
69 }
71
70
@@ -76,8 +75,7 void ChartDateTimeAxisY::updateGeometry()
76 {
75 {
77 const QVector<qreal> &layout = ChartAxis::layout();
76 const QVector<qreal> &layout = ChartAxis::layout();
78
77
79 if (layout.isEmpty())
78 if(layout.isEmpty()) return;
80 return;
81
79
82 QStringList ticksList;
80 QStringList ticksList;
83
81
@@ -91,16 +89,14 void ChartDateTimeAxisY::updateGeometry()
91 Q_ASSERT(labels.size() == ticksList.size());
89 Q_ASSERT(labels.size() == ticksList.size());
92 Q_ASSERT(layout.size() == ticksList.size());
90 Q_ASSERT(layout.size() == ticksList.size());
93
91
94 QRectF chartRect = presenter()->chartsGeometry();
92 qreal height = m_gridRect.bottom();
95
96 qreal height = chartRect.bottom();
97
93
98 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
94 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
99 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
95 lineItem->setLine(m_gridRect.left() , m_gridRect.top(), m_gridRect.left(), m_gridRect.bottom());
100
96
101 for (int i = 0; i < layout.size(); ++i) {
97 for (int i = 0; i < layout.size(); ++i) {
102 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
98 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
103 lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
99 lineItem->setLine(m_gridRect.left() , layout[i], m_gridRect.right(), layout[i]);
104 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
100 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
105
101
106 labelItem->setText(ticksList.at(i));
102 labelItem->setText(ticksList.at(i));
@@ -108,12 +104,13 void ChartDateTimeAxisY::updateGeometry()
108
104
109 QPointF center = rect.center();
105 QPointF center = rect.center();
110 labelItem->setTransformOriginPoint(center.x(), center.y());
106 labelItem->setTransformOriginPoint(center.x(), center.y());
111 labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] - center.y());
107 labelItem->setPos(m_gridRect.left() - rect.width() - label_padding , layout[i]-center.y());
112
108
113 if (labelItem->pos().y() + rect.height() > height) {
109 if(labelItem->pos().y()+rect.height()>height) {
114 labelItem->setVisible(false);
110 labelItem->setVisible(false);
115 lineItem->setVisible(false);
111 lineItem->setVisible(false);
116 } else {
112 }
113 else {
117 labelItem->setVisible(true);
114 labelItem->setVisible(true);
118 lineItem->setVisible(true);
115 lineItem->setVisible(true);
119 height = labelItem->pos().y();
116 height=labelItem->pos().y();
@@ -121,10 +118,10 void ChartDateTimeAxisY::updateGeometry()
121
118
122 if ((i + 1) % 2 && i > 1) {
119 if ((i+1)%2 && i>1) {
123 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
120 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
124 rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
121 rectItem->setRect(m_gridRect.left(),layout[i],m_gridRect.width(),layout[i-1]-layout[i]);
125 }
122 }
126 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
123 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
127 lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]);
124 lineItem->setLine(m_gridRect.left()-5,layout[i],m_gridRect.left(),layout[i]);
128 }
125 }
129 }
126 }
130
127
@@ -148,13 +145,17 QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint
148 sh = QSizeF(fn.boundingRect("...").width(), fn.height());
145 sh = QSizeF(fn.boundingRect("...").width(),fn.height());
149 break;
146 break;
150 case Qt::PreferredSize: {
147 case Qt::PreferredSize:{
148
151 const QVector<qreal>& layout = ChartAxis::layout();
149 const QVector<qreal>& layout = ChartAxis::layout();
152 if (layout.isEmpty())
150 if(layout.isEmpty()) break;
153 break;
154 QStringList ticksList;
151 QStringList ticksList;
152
153
155 qreal width = 0;
154 qreal width=0;
156 qreal height = 0;
155 qreal height=0;
157 for (int i = 0; i < ticksList.size(); ++i) {
156
157 for (int i = 0; i < ticksList.size(); ++i)
158 {
158 QRectF rect = fn.boundingRect(ticksList.at(i));
159 QRectF rect = fn.boundingRect(ticksList.at(i));
159 width += rect.width();
160 width+=rect.width();
160 height += qMax(rect.height() + label_padding, height);
161 height+=qMax(rect.height()+label_padding,height);
Show file before | Show file after | Hide comments
@@ -260,8 +260,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
260 QChart when axis added.
260 QChart when axis added.
261 */
261 */
262
262
263 QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
263 QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent) :
264 : QObject(parent),
264 QObject(parent),
265 d_ptr(&d)
265 d_ptr(&d)
266 {
266 {
267 }
267 }
@@ -272,8 +272,7 QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
272
272
273 QAbstractAxis::~QAbstractAxis()
273 QAbstractAxis::~QAbstractAxis()
274 {
274 {
275 if (d_ptr->m_dataset)
275 if(d_ptr->m_dataset) qFatal("Still binded axis detected !");
276 qFatal("Still binded axis detected !");
277 }
276 }
278
277
279 /*!
278 /*!
@@ -689,26 +688,27 void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
689 /*!
688 /*!
690 Returns the orientation in which the axis is being used (Vertical or Horizontal)
689 Returns the orientation in which the axis is being used (Vertical or Horizontal)
691 */
690 */
692 Qt::Orientation QAbstractAxis::orientation()
691 Qt::Orientation QAbstractAxis::orientation() const
693 {
692 {
694 return d_ptr->m_orientation;
693 return d_ptr->m_orientation;
695 }
694 }
696
695
697 bool QAbstractAxis::alternativePlacement() const
696 Qt::Alignment QAbstractAxis::alignment() const
698 {
697 {
699 return d_ptr->m_alternativePlacement;
698 return d_ptr->m_alignment;
700 }
699 }
701
700
702 void QAbstractAxis::setAlternativePlacement(bool placement)
701 void QAbstractAxis::setAlignment(Qt::Alignment alignment)
703 {
702 {
704 d_ptr->m_alternativePlacement = placement;
703 d_ptr->m_alignment=alignment;
705 }
704 }
706
705
707 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
706 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
708
707
709 QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
708 QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q):
710 : q_ptr(q),
709 q_ptr(q),
711 m_orientation(Qt::Orientation(0)),
710 m_orientation(Qt::Orientation(0)),
711 m_alignment(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),
@@ -718,8 +718,7 QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
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)
723 {
722 {
724
723
725 }
724 }
@@ -745,6 +744,10 void QAbstractAxisPrivate::setDirty(bool dirty)
745 void QAbstractAxisPrivate::setOrientation(Qt::Orientation orientation)
744 void QAbstractAxisPrivate::setOrientation(Qt::Orientation orientation)
746 {
745 {
747 m_orientation = orientation;
746 m_orientation=orientation;
747 if(m_orientation==Qt::Horizontal && !m_alignment)
748 m_alignment=Qt::AlignBottom;
749 else if(m_orientation==Qt::Vertical && !m_alignment)
750 m_alignment=Qt::AlignLeft;
748 }
751 }
749
752
750
753
Show file before | Show file after | Hide comments
@@ -123,9 +123,9 public:
123 void setShadesBorderColor(QColor color);
123 void setShadesBorderColor(QColor color);
124 QColor shadesBorderColor() const;
124 QColor shadesBorderColor() const;
125
125
126 Qt::Orientation orientation();
126 Qt::Orientation orientation() const;
127 bool alternativePlacement() const;
127 Qt::Alignment alignment() const;
128 void setAlternativePlacement(bool placement);
128 void setAlignment( Qt::Alignment alignment);
129
129
130 //range handling
130 //range handling
131 void setMin(const QVariant &min);
131 void setMin(const QVariant &min);
Show file before | Show file after | Hide comments
@@ -75,6 +75,7 Q_SIGNALS:
75 protected:
75 protected:
76 QAbstractAxis *q_ptr;
76 QAbstractAxis *q_ptr;
77 Qt::Orientation m_orientation;
77 Qt::Orientation m_orientation;
78 Qt::Alignment m_alignment;
78 ChartDataSet *m_dataset;
79 ChartDataSet *m_dataset;
79
80
80 private:
81 private:
@@ -106,8 +107,6 private:
106
107
107 bool m_dirty;
108 bool m_dirty;
108
109
109 bool m_alternativePlacement;
110
111 friend class QAbstractAxis;
110 friend class QAbstractAxis;
112 friend class ChartDataSet;
111 friend class ChartDataSet;
113 };
112 };
Show file before | Show file after | Hide comments
@@ -25,14 +25,10
25 #include <QGraphicsLayout>
25 #include <QGraphicsLayout>
26 #include <QFontMetrics>
26 #include <QFontMetrics>
27 #include <qmath.h>
27 #include <qmath.h>
28 #include <QDebug>
29
30 static int label_padding = 5;
31
28
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
30
34 ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
31 ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
35 : ChartAxis(axis, presenter),
36 m_tickCount(0)
32 m_tickCount(0)
37 {
33 {
38 }
34 }
@@ -48,11 +44,9 QVector<qreal> ChartValueAxisX::calculateLayout() const
48 QVector<qreal> points;
44 QVector<qreal> points;
49 points.resize(m_tickCount);
45 points.resize(m_tickCount);
50
46
51 QRectF rect = presenter()->chartsGeometry();
47 const qreal deltaX = m_gridRect.width()/(m_tickCount-1);
52
53 const qreal deltaX = rect.width() / (m_tickCount - 1);
54 for (int i = 0; i < m_tickCount; ++i) {
48 for (int i = 0; i < m_tickCount; ++i) {
55 int x = i * deltaX + rect.left();
49 int x = i * deltaX + m_gridRect.left();
56 points[i] = x;
50 points[i] = x;
57 }
51 }
58 return points;
52 return points;
@@ -62,8 +56,7 void ChartValueAxisX::updateGeometry()
62 {
56 {
63 const QVector<qreal>& layout = ChartAxis::layout();
57 const QVector<qreal>& layout = ChartAxis::layout();
64
58
65 if (layout.isEmpty())
59 if(layout.isEmpty()) return;
66 return;
67
60
68 QStringList ticksList = createNumberLabels(m_min, m_max, layout.size());
61 QStringList ticksList = createNumberLabels(m_min,m_max,layout.size());
69
62
@@ -75,32 +68,33 void ChartValueAxisX::updateGeometry()
75 Q_ASSERT(labels.size() == ticksList.size());
68 Q_ASSERT(labels.size() == ticksList.size());
76 Q_ASSERT(layout.size() == ticksList.size());
69 Q_ASSERT(layout.size() == ticksList.size());
77
70
78 QRectF chartRrect = presenter()->chartsGeometry();
79
80 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
71 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
81 // lineItem->setLine(chartRrect.left(), chartRrect.bottom(), chartRrect.right(), chartRrect.bottom());
72 //lineItem->setLine(m_gridRect.left(), m_gridRect.bottom(), m_gridRect.right(), m_gridRect.bottom());
82 if (m_chartAxis->alternativePlacement())
73
83 lineItem->setLine(chartRrect.left(), m_internalRect.top(), chartRrect.right(), m_internalRect.top());
74 if (m_chartAxis->alignment()==Qt::AlignTop)
84 else
75 lineItem->setLine(m_gridRect.left(), m_axisRect.bottom(), m_gridRect.right(), m_axisRect.bottom());
85 lineItem->setLine(chartRrect.left(), m_internalRect.bottom(), chartRrect.right(), m_internalRect.bottom());
76 else if(m_chartAxis->alignment()==Qt::AlignBottom)
77 lineItem->setLine(m_gridRect.left(), m_axisRect.top(), m_gridRect.right(), m_axisRect.top());
86
78
87 qreal width = 0;
79 qreal width = 0;
88 for (int i = 0; i < layout.size(); ++i) {
80 for (int i = 0; i < layout.size(); ++i) {
89 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
81 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
90 lineItem->setLine(layout[i], chartRrect.top(), layout[i], chartRrect.bottom());
82 lineItem->setLine(layout[i], m_gridRect.top(), layout[i], m_gridRect.bottom());
91 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
83 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
92 labelItem->setText(ticksList.at(i));
84 labelItem->setText(ticksList.at(i));
93 const QRectF &rect = labelItem->boundingRect();
85 const QRectF& rect = labelItem->boundingRect();
94 QPointF center = rect.center();
86 QPointF center = rect.center();
95 labelItem->setTransformOriginPoint(center.x(), center.y());
87 labelItem->setTransformOriginPoint(center.x(), center.y());
96 // labelItem->setPos(layout[i] - center.x(), chartRrect.bottom() + label_padding);
88 //labelItem->setPos(layout[i] - center.x(), m_gridRect.bottom() + label_padding);
97 if (m_chartAxis->alternativePlacement())
89
98 labelItem->setPos(layout[i] - center.x(), m_internalRect.top() - rect.height() - label_padding);
90 if (m_chartAxis->alignment()==Qt::AlignTop)
99 else
91 labelItem->setPos(layout[i] - center.x(), m_axisRect.bottom() - rect.height() - labelPadding());
100 labelItem->setPos(layout[i] - center.x(), m_internalRect.bottom() + label_padding);
92 else if(m_chartAxis->alignment()==Qt::AlignBottom)
93 labelItem->setPos(layout[i] - center.x(), m_axisRect.top() + labelPadding());
94
101 if (labelItem->pos().x() <= width ||
95 if(labelItem->pos().x() <= width ||
102 labelItem->pos().x() < m_rect.left() ||
96 labelItem->pos().x() < m_axisRect.left() ||
103 labelItem->pos().x() + rect.width() > m_rect.right()) {
97 labelItem->pos().x() + rect.width() > m_axisRect.right()){
104 labelItem->setVisible(false);
98 labelItem->setVisible(false);
105 lineItem->setVisible(false);
99 lineItem->setVisible(false);
106 } else {
100 }else{
@@ -111,14 +105,16 void ChartValueAxisX::updateGeometry()
111
105
112 if ((i + 1) % 2 && i > 1) {
106 if ((i+1)%2 && i>1) {
113 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
107 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());
108 rectItem->setRect(layout[i-1],m_gridRect.top(),layout[i]-layout[i-1],m_gridRect.height());
115 }
109 }
116 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
110 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
117 // lineItem->setLine(layout[i],chartRrect.bottom(),layout[i],chartRrect.bottom()+5);
111 //lineItem->setLine(layout[i],m_gridRect.bottom(),layout[i],m_gridRect.bottom()+5);
118 if (m_chartAxis->alternativePlacement())
112
119 lineItem->setLine(layout[i], m_internalRect.top(), layout[i], m_internalRect.top() - 5);
113 if (m_chartAxis->alignment()==Qt::AlignTop)
120 else
114 lineItem->setLine(layout[i],m_axisRect.bottom(),layout[i],m_axisRect.bottom() - labelPadding());
121 lineItem->setLine(layout[i], m_internalRect.bottom(), layout[i], m_internalRect.bottom() + 5);
115 else if(m_chartAxis->alignment()==Qt::AlignBottom)
116 lineItem->setLine(layout[i],m_axisRect.top(),layout[i],m_axisRect.top() + labelPadding());
117
122 }
118 }
123 }
119 }
124
120
@@ -126,10 +122,7 void ChartValueAxisX::handleAxisUpdated()
126 {
122 {
127 //TODO:: fix this
123 //TODO:: fix this
128 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
124 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
129 if (m_tickCount != axis->tickCount()) {
130 m_tickCount = axis->tickCount();
125 m_tickCount = axis->tickCount();
131 presenter()->layout()->invalidate();
132 }
133 ChartAxis::handleAxisUpdated();
126 ChartAxis::handleAxisUpdated();
134 }
127 }
135
128
@@ -149,20 +142,23 QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) c
149 case Qt::MinimumSize: {
142 case Qt::MinimumSize:{
150 int count = qMax(ticksList.last().count(), ticksList.first().count());
143 int count = qMax(ticksList.last().count(),ticksList.first().count());
151 width = fn.averageCharWidth() * count;
144 width=fn.averageCharWidth()*count;
152 height = fn.height() + label_padding;
145 height=fn.height()+labelPadding();
153 width = qMax(width, base.width());
146 width=qMax(width,base.width());
154 height += base.height();
147 height+=base.height();
155 sh = QSizeF(width, height);
148 sh = QSizeF(width,height);
156 break;
149 break;
157 }
150 }
158 case Qt::PreferredSize:
151 case Qt::PreferredSize:{
159 for (int i = 0; i < ticksList.size(); ++i)
152 for (int i = 0; i < ticksList.size(); ++i)
153 {
160 width += fn.averageCharWidth() * ticksList.at(i).count();
154 width+=fn.averageCharWidth()*ticksList.at(i).count();
161 height = fn.height() + label_padding;
155 }
156 height=fn.height()+labelPadding();
162 width = qMax(width, base.width());
157 width=qMax(width,base.width());
163 height += base.height();
158 height+=base.height();
164 sh = QSizeF(width, height);
159 sh = QSizeF(width,height);
165 break;
160 break;
161 }
166 default:
162 default:
167 break;
163 break;
168 }
164 }
Show file before | Show file after | Hide comments
@@ -27,12 +27,9
27 #include <qmath.h>
27 #include <qmath.h>
28 #include <QDebug>
28 #include <QDebug>
29
29
30 static int label_padding = 5;
31
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
31
34 ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
32 ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
35 : ChartAxis(axis, presenter),
36 m_tickCount(0)
33 m_tickCount(0)
37 {
34 {
38 }
35 }
@@ -48,11 +45,9 QVector<qreal> ChartValueAxisY::calculateLayout() const
48 QVector<qreal> points;
45 QVector<qreal> points;
49 points.resize(m_tickCount);
46 points.resize(m_tickCount);
50
47
51 QRectF rect = presenter()->chartsGeometry();
48 const qreal deltaY = m_gridRect.height()/(m_tickCount-1);
52
53 const qreal deltaY = rect.height() / (m_tickCount - 1);
54 for (int i = 0; i < m_tickCount; ++i) {
49 for (int i = 0; i < m_tickCount; ++i) {
55 int y = i * -deltaY + rect.bottom();
50 int y = i * -deltaY + m_gridRect.bottom();
56 points[i] = y;
51 points[i] = y;
57 }
52 }
58
53
@@ -63,8 +58,7 void ChartValueAxisY::updateGeometry()
63 {
58 {
64 const QVector<qreal> &layout = ChartAxis::layout();
59 const QVector<qreal> &layout = ChartAxis::layout();
65
60
66 if (layout.isEmpty())
61 if(layout.isEmpty()) return;
67 return;
68
62
69 QStringList ticksList = createNumberLabels(m_min, m_max, layout.size());
63 QStringList ticksList = createNumberLabels(m_min,m_max,layout.size());
70
64
@@ -76,29 +70,29 void ChartValueAxisY::updateGeometry()
76 Q_ASSERT(labels.size() == ticksList.size());
70 Q_ASSERT(labels.size() == ticksList.size());
77 Q_ASSERT(layout.size() == ticksList.size());
71 Q_ASSERT(layout.size() == ticksList.size());
78
72
79 QRectF chartRect = presenter()->chartsGeometry();
73 qreal height = m_axisRect.bottom();
80
81 qreal height = m_rect.bottom();
82
74
83 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
75 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
84 // lineItem->setLine( chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
76 //lineItem->setLine( m_gridRect.left() , m_gridRect.top(), m_gridRect.left(), m_gridRect.bottom());
85 if (m_chartAxis->alternativePlacement())
77
86 lineItem->setLine(m_internalRect.right(), chartRect.top(), m_internalRect.right(), chartRect.bottom());
78 if (m_chartAxis->alignment()==Qt::AlignLeft)
87 else
79 lineItem->setLine( m_axisRect.right() , m_gridRect.top(), m_axisRect.right(), m_gridRect.bottom());
88 lineItem->setLine(m_internalRect.left(), chartRect.top(), m_internalRect.left(), chartRect.bottom());
80 else if(m_chartAxis->alignment()==Qt::AlignRight)
81 lineItem->setLine( m_axisRect.left() , m_gridRect.top(), m_axisRect.left(), m_gridRect.bottom());
89
82
90 QFontMetrics fn(m_font);
83 QFontMetrics fn(m_font);
91
84
92 for (int i = 0; i < layout.size(); ++i) {
85 for (int i = 0; i < layout.size(); ++i) {
93 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
86 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
94 lineItem->setLine(chartRect.left(), layout[i], chartRect.right(), layout[i]);
87 lineItem->setLine( m_gridRect.left() , layout[i], m_gridRect.right(), layout[i]);
95 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
88 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
96
89
97 QString text = ticksList.at(i);
90 QString text = ticksList.at(i);
98
91
99 if (fn.boundingRect(text).width() > chartRect.left() - m_rect.left() - label_padding) {
92 if (fn.boundingRect(text).width() > m_axisRect.right() - m_axisRect.left() - labelPadding() )
93 {
100 QString label = text + "...";
94 QString label = text + "...";
101 while (fn.boundingRect(label).width() > chartRect.left() - m_rect.left() - label_padding && label.length() > 3)
95 while (fn.boundingRect(label).width() > m_axisRect.right() - m_axisRect.left() - labelPadding() && label.length() > 3)
102 label.remove(label.length() - 4, 1);
96 label.remove(label.length() - 4, 1);
103 labelItem->setText(label);
97 labelItem->setText(label);
104 } else {
98 }else{
@@ -109,14 +103,15 void ChartValueAxisY::updateGeometry()
109
103
110 QPointF center = rect.center();
104 QPointF center = rect.center();
111 labelItem->setTransformOriginPoint(center.x(), center.y());
105 labelItem->setTransformOriginPoint(center.x(), center.y());
112 // labelItem->setPos( chartRect.left() - rect.width() - label_padding , layout[i]-center.y());
106 //labelItem->setPos( m_gridRect.left() - rect.width() - labelPadding() , layout[i]-center.y());
113 if (m_chartAxis->alternativePlacement())
107
114 labelItem->setPos(m_internalRect.right() + label_padding , layout[i] - center.y());
108 if (m_chartAxis->alignment()==Qt::AlignLeft)
115 else
109 labelItem->setPos( m_axisRect.right() - rect.width() - labelPadding() , layout[i]-center.y());
116 labelItem->setPos(m_internalRect.left() - rect.width() - label_padding , layout[i] - center.y());
110 else if(m_chartAxis->alignment()==Qt::AlignRight)
111 labelItem->setPos( m_axisRect.left() + labelPadding() , layout[i]-center.y());
117
112
118 if (labelItem->pos().y() + rect.height() > height ||
113 if(labelItem->pos().y() + rect.height() > height ||
119 labelItem->pos().y() < m_rect.top()) {
114 labelItem->pos().y() < m_axisRect.top()) {
120 labelItem->setVisible(false);
115 labelItem->setVisible(false);
121 lineItem->setVisible(false);
116 lineItem->setVisible(false);
122 } else {
117 }else{
@@ -127,14 +122,16 void ChartValueAxisY::updateGeometry()
127
122
128 if ((i + 1) % 2 && i > 1) {
123 if ((i+1)%2 && i>1) {
129 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
124 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
130 rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
125 rectItem->setRect( m_gridRect.left(),layout[i], m_gridRect.width(),layout[i-1]-layout[i]);
131 }
126 }
132 lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
127 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
133 // lineItem->setLine( chartRect.left()-5,layout[i], chartRect.left(),layout[i]);
128 // lineItem->setLine( m_gridRect.left()-5,layout[i], m_gridRect.left(),layout[i]);
134 if (m_chartAxis->alternativePlacement())
129
135 lineItem->setLine(m_internalRect.right() + 5, layout[i], m_internalRect.right(), layout[i]);
130 if (m_chartAxis->alignment()==Qt::AlignLeft)
136 else
131 lineItem->setLine( m_axisRect.right()- labelPadding(),layout[i], m_axisRect.right(),layout[i]);
137 lineItem->setLine(m_internalRect.left() - 5, layout[i], m_internalRect.left(), layout[i]);
132 else if(m_chartAxis->alignment()==Qt::AlignRight)
133 lineItem->setLine( m_axisRect.left(),layout[i], m_axisRect.left()+ labelPadding(),layout[i]);
134
138 }
135 }
139 }
136 }
140
137
@@ -142,10 +139,7 void ChartValueAxisY::handleAxisUpdated()
142 {
139 {
143 //TODO:: fix this
140 //TODO:: fix this
144 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
141 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
145 if (m_tickCount != axis->tickCount()) {
146 m_tickCount = axis->tickCount();
142 m_tickCount = axis->tickCount();
147 presenter()->layout()->invalidate();
148 }
149 ChartAxis::handleAxisUpdated();
143 ChartAxis::handleAxisUpdated();
150 }
144 }
151
145
@@ -163,7 +157,7 QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) c
163 switch (which) {
157 switch (which) {
164 case Qt::MinimumSize: {
158 case Qt::MinimumSize: {
165 int count = qMax(ticksList.first().count() , ticksList.last().count());
159 int count = qMax(ticksList.first().count() , ticksList.last().count());
166 width = fn.averageCharWidth() * count + label_padding;
160 width=fn.averageCharWidth()*count+labelPadding();
167 height = fn.height();
161 height=fn.height();
168 height = qMax(height, base.height());
162 height=qMax(height,base.height());
169 width += base.width();
163 width+=base.width();
@@ -171,14 +165,17 QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) c
171 break;
165 break;
172 }
166 }
173 case Qt::PreferredSize:
167 case Qt::PreferredSize:
174 for (int i = 0; i < ticksList.size(); ++i) {
168 {
175 width = qMax(qreal(fn.averageCharWidth() * ticksList.at(i).count()) + label_padding, width);
169 for (int i = 0; i < ticksList.size(); ++i)
170 {
171 width=qMax(qreal(fn.averageCharWidth()*ticksList.at(i).count())+labelPadding(),width);
176 height += fn.height();
172 height+=fn.height();
177 }
173 }
178 height = qMax(height, base.height());
174 height=qMax(height,base.height());
179 width += base.width();
175 width+=base.width();
180 sh = QSizeF(width, height);
176 sh = QSizeF(width,height);
181 break;
177 break;
178 }
182 default:
179 default:
183 break;
180 break;
184 }
181 }
Show file before | Show file after | Hide comments
@@ -25,13 +25,14
25 #include "charttitle_p.h"
25 #include "charttitle_p.h"
26 #include "chartbackground_p.h"
26 #include "chartbackground_p.h"
27 #include "legendmarker_p.h"
27 #include "legendmarker_p.h"
28 #include <QDebug>
28
29
29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30
31
31 static const qreal golden_ratio = 0.25;
32 static const qreal golden_ratio = 0.25;
32
33
33 ChartLayout::ChartLayout(ChartPresenter *presenter)
34 ChartLayout::ChartLayout(ChartPresenter* presenter):
34 : m_presenter(presenter),
35 m_presenter(presenter),
35 m_margins(20, 20, 20, 20),
36 m_margins(20,20,20,20),
36 m_minChartRect(0, 0, 200, 200)
37 m_minChartRect(0,0,200,200)
37 {
38 {
@@ -49,6 +50,7 void ChartLayout::setGeometry(const QRectF &rect)
49 return;
50 return;
50
51
51 QList<ChartAxis *> axes = m_presenter->axisItems();
52 QList<ChartAxis*> axes = m_presenter->axisItems();
53 QList<ChartElement*> charts = m_presenter->chartItems();
52 ChartTitle *title = m_presenter->titleElement();
54 ChartTitle* title = m_presenter->titleElement();
53 QLegend *legend = m_presenter->legend();
55 QLegend* legend = m_presenter->legend();
54 ChartBackground *background = m_presenter->backgroundElement();
56 ChartBackground* background = m_presenter->backgroundElement();
@@ -57,27 +59,17 void ChartLayout::setGeometry(const QRectF &rect)
57
59
58 contentGeometry = calculateContentGeometry(contentGeometry);
60 contentGeometry = calculateContentGeometry(contentGeometry);
59
61
60 if (title && title->isVisible())
62 if (title && title->isVisible()) {
61 contentGeometry = calculateTitleGeometry(contentGeometry, title);
63 contentGeometry = calculateTitleGeometry(contentGeometry,title);
64 }
62
65
63 if (legend->isAttachedToChart() && legend->isVisible())
66 if (legend->isAttachedToChart() && legend->isVisible()) {
64 contentGeometry = calculateLegendGeometry(contentGeometry, legend);
67 contentGeometry = calculateLegendGeometry(contentGeometry,legend);
68 }
65
69
66 calculateChartGeometry(contentGeometry, axes);
70 contentGeometry = calculateAxisGeometry(contentGeometry,axes);
67
71
68 //TODO remove me
72 m_chartsRect = calculateChartsGeometry(contentGeometry,charts);
69 #ifdef SHOW_LAYOUT
70 LayoutDebuger *debuger = LayoutDebuger::instance();
71 debuger->reset();
72 debuger->setPen(QPen(Qt::red));
73 debuger->add(backgroundGeometry, m_presenter->rootItem());
74 debuger->add(titleGeometry, m_presenter->rootItem());
75 debuger->add(legendGeometry , m_presenter->rootItem());
76 debuger->add(axisGeometry , m_presenter->rootItem());
77 debuger->add(geometry, m_presenter->rootItem());
78 foreach(LegendMarker * marker, legend->d_ptr->markers())
79 debuger->add(marker->mapRectToScene(marker->boundingRect()), m_presenter->rootItem());
80 #endif
81
73
82 QGraphicsLayout::setGeometry(rect);
74 QGraphicsLayout::setGeometry(rect);
83 }
75 }
@@ -98,8 +90,7 QRectF ChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBac
98 qreal left, top, right, bottom;
90 qreal left, top, right, bottom;
99 getContentsMargins(&left, &top, &right, &bottom);
91 getContentsMargins(&left, &top, &right, &bottom);
100 QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
92 QRectF backgroundGeometry = geometry.adjusted(left,top,-right,-bottom);
101 if (background)
93 if(background) background->setRect(backgroundGeometry);
102 background->setRect(backgroundGeometry);
103 return backgroundGeometry;
94 return backgroundGeometry;
104 }
95 }
105
96
@@ -110,86 +101,130 QRectF ChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
110 return minimum.adjusted(0, 0, left + right, top + bottom);
101 return minimum.adjusted(0,0,left + right,top+bottom);
111 }
102 }
112
103
113 QRectF ChartLayout::calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
114 {
115
104
116 QSizeF vertical(0, 0);
105 QRectF ChartLayout::calculateAxisGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const
117 QSizeF horizontal(0, 0);
106 {
118
107
119 int topAxisCount = 0;
108 QSizeF left;
120 int bottomAxisCount = 0;
109 QSizeF right;
121 int leftAxisCount = 0;
110 QSizeF bottom;
122 int rightAxisCount = 0;
111 QSizeF top;
112 int leftCount = 0;
113 int rightCount = 0;
114 int topCount = 0;
115 int bottomCount = 0;
123
116
124 // check axis size
125 foreach (ChartAxis *axis , axes) {
117 foreach(ChartAxis* axis , axes) {
126 if (axis->orientation() == Qt::Vertical && axis->isVisible()) {
118
127 // vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
119 if(!axis->isVisible()) continue;
128 if (axis->alternativePlacement())
120
129 rightAxisCount++;
121 QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
130 else
122
131 leftAxisCount++;
123 switch(axis->alignment()){
132 } else if (axis->orientation() == Qt::Horizontal && axis->isVisible()) {
124 case Qt::AlignLeft:
133 // horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
125 left.setWidth(left.width()+size.width());
134 if (axis->alternativePlacement())
126 left.setHeight(qMax(left.height(),size.height()));
135 topAxisCount++;
127 leftCount++;
136 else
128 break;
137 bottomAxisCount++;
129 case Qt::AlignRight:
130 right.setWidth(right.width()+size.width());
131 right.setHeight(qMax(right.height(),size.height()));
132 rightCount++;
133 break;
134 case Qt::AlignTop:
135 top.setWidth(qMax(top.width(),size.width()));
136 top.setHeight(top.height()+size.height());
137 topCount++;
138 break;
139 case Qt::AlignBottom:
140 bottom.setWidth(qMax(bottom.width(),size.width()));
141 bottom.setHeight(bottom.height() + size.height());
142 bottomCount++;
143 break;
144
138 }
145 }
139 }
146 }
140
147
141 qreal width = qMin(vertical.width(), geometry.width() * golden_ratio);
148 left.setWidth(qMax(qMax(top.width()/2,bottom.width()/2),left.width()));
149 left.setWidth(qMin(left.width(),golden_ratio*geometry.width()));
150 right.setWidth(qMax(qMax(top.width()/2,bottom.width()/2),right.width()));
151 right.setWidth(qMin(right.width(),golden_ratio*geometry.width()));
152 top.setHeight(qMax(qMax(left.height()/2,right.height()/2),top.height()));
153 bottom.setHeight(qMax(qMax(left.height()/2,right.height()/2),bottom.height()));
154
155 QRectF chartRect = geometry.adjusted(left.width(),top.height(),-right.width(),-bottom.height());
142
156
143 QRectF rect = geometry.adjusted(width, vertical.height() / 2, -horizontal.width() / 2, -horizontal.height());
157 qreal leftOffset=0;
158 qreal rightOffset=0;
159 qreal topOffset=0;
160 qreal bottomOffset=0;
144
161
145 // axis area width
162 foreach(ChartAxis* axis , axes) {
146 // TODO: replase with dynamic size code
147 int axisWidth = 35;
148
163
149 // get the final size of the plot rect
164 if(!axis->isVisible()) continue;
150 rect.adjust(leftAxisCount * axisWidth, topAxisCount * axisWidth, -rightAxisCount * axisWidth, -bottomAxisCount * axisWidth);
151 m_presenter->setChartsGeometry(rect);
152
165
153 leftAxisCount = 0;
166 QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
154 rightAxisCount = 0;
155 bottomAxisCount = 0;
156 topAxisCount = 0;
157
167
158 // adjust the axes internal and external rects
168 switch(axis->alignment()){
159 foreach (ChartAxis *axis , axes) {
169 case Qt::AlignLeft:{
160 if (axis->orientation() == Qt::Vertical) {
170 qreal width = qMin(size.width(),left.width()/leftCount);
161 axis->setInternalRect(rect.adjusted(-leftAxisCount * axisWidth, 0, rightAxisCount * axisWidth, 0));
171 leftOffset+=width;
162 axis->setGeometry(rect.adjusted(-(leftAxisCount + 1) * axisWidth, 0, (rightAxisCount + 1) * axisWidth, 0));
172 axis->setGeometry(QRect(chartRect.left()-leftOffset,chartRect.top()-(size.height()+1)/2,width,chartRect.height()+size.height()+2),chartRect);
163 if (axis->alternativePlacement())
173 break;
164 rightAxisCount++;
174 }
165 else
175 case Qt::AlignRight:{
166 leftAxisCount++;
176 qreal width = qMin(size.width(),right.width()/rightCount);
167 } else if (axis->orientation() == Qt::Horizontal) {
177 axis->setGeometry(QRect(chartRect.right()+rightOffset,chartRect.top()-(size.height()+1)/2,width,chartRect.height()+size.height()+2),chartRect);
168 axis->setInternalRect(rect.adjusted(0, -topAxisCount * axisWidth, 0, bottomAxisCount * axisWidth));
178 rightOffset+=width;
169 axis->setGeometry(rect.adjusted(0, -(topAxisCount + 1) * axisWidth, 0, (bottomAxisCount + 1) * axisWidth));
179 break;
170 if (axis->alternativePlacement())
180 }
171 topAxisCount++;
181 case Qt::AlignTop:
172 else
182 axis->setGeometry(QRect(geometry.left(),chartRect.top()-topOffset - size.height(),geometry.width(),size.height()),chartRect);
173 bottomAxisCount++;
183 topOffset+=size.height();
184 break;
185 case Qt::AlignBottom:
186 axis->setGeometry(QRect(geometry.left(),chartRect.bottom()+bottomOffset,geometry.width(),size.height()),chartRect);
187 bottomOffset+=size.height();
188 break;
174 }
189 }
175 }
190 }
176
191
177 return rect;
192 return chartRect;
178 }
193 }
179
194
180 QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const
195 QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const
181 {
196 {
182 QSizeF vertical(0, 0);
197 QSizeF left;
183 QSizeF horizontal(0, 0);
198 QSizeF right;
199 QSizeF bottom;
200 QSizeF top;
184
201
185 // check axis size
186 foreach (ChartAxis *axis , axes) {
202 foreach(ChartAxis* axis , axes) {
187 if (axis->orientation() == Qt::Vertical && axis->isVisible())
203
188 vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
204 QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
189 else if (axis->orientation() == Qt::Horizontal && axis->isVisible())
205
190 horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
206 if(!axis->isVisible()) continue;
207
208 switch(axis->alignment()) {
209 case Qt::AlignLeft:
210 left.setWidth(left.width()+size.width());
211 left.setHeight(qMax(left.height()*2,size.height()));
212 break;
213 case Qt::AlignRight:
214 right.setWidth(right.width()+size.width());
215 right.setHeight(qMax(right.height()*2,size.height()));
216 break;
217 case Qt::AlignTop:
218 top.setWidth(qMax(top.width(),size.width()));
219 top.setHeight(top.height()+size.height());
220 break;
221 case Qt::AlignBottom:
222 bottom.setWidth(qMax(bottom.width(),size.width()));
223 bottom.setHeight(bottom.height() + size.height());
224 break;
191 }
225 }
192 return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height());
226 }
227 return minimum.adjusted(0,0,left.width() + right.width() + qMax(top.width(),bottom.width()), top.height() + bottom.height() + qMax(left.height(),right.height()));
193 }
228 }
194
229
195 QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
230 QRectF ChartLayout::calculateLegendGeometry(const QRectF& geometry,QLegend* legend) const
@@ -199,14 +234,16 QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *leg
199 QRectF result;
234 QRectF result;
200
235
201 switch (legend->alignment()) {
236 switch (legend->alignment()) {
202 case Qt::AlignTop:
237 case Qt::AlignTop: {
203 legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
238 legendRect = QRectF(geometry.topLeft(),QSizeF(geometry.width(),size.height()));
204 result = geometry.adjusted(0, legendRect.height(), 0, 0);
239 result = geometry.adjusted(0,legendRect.height(),0,0);
205 break;
240 break;
206 case Qt::AlignBottom:
241 }
242 case Qt::AlignBottom: {
207 legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
243 legendRect = QRectF(QPointF(geometry.left(),geometry.bottom()-size.height()),QSizeF(geometry.width(),size.height()));
208 result = geometry.adjusted(0, 0, 0, -legendRect.height());
244 result = geometry.adjusted(0,0,0,-legendRect.height());
209 break;
245 break;
246 }
210 case Qt::AlignLeft: {
247 case Qt::AlignLeft: {
211 qreal width = qMin(size.width(), geometry.width() * golden_ratio);
248 qreal width = qMin(size.width(),geometry.width()*golden_ratio);
212 legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
249 legendRect = QRectF(geometry.topLeft(),QSizeF(width,geometry.height()));
@@ -219,17 +256,31 QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *leg
219 result = geometry.adjusted(0, 0, -width, 0);
256 result = geometry.adjusted(0,0,-width,0);
220 break;
257 break;
221 }
258 }
222 default:
259 default: {
223 legendRect = QRectF(0, 0, 0, 0);
260 legendRect = QRectF(0,0,0,0);
224 result = geometry;
261 result = geometry;
225 break;
262 break;
226 }
263 }
264 }
227
265
228 legend->setGeometry(legendRect);
266 legend->setGeometry(legendRect);
229
267
230 return result;
268 return result;
231 }
269 }
232
270
271
272 QRectF ChartLayout::calculateChartsGeometry(const QRectF& geometry, const QList<ChartElement*>& charts) const
273 {
274 Q_ASSERT(geometry.isValid());
275
276 foreach(ChartElement* chart, charts)
277 {
278 chart->handleGeometryChanged(geometry);
279 }
280
281 return geometry;
282 }
283
233 QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
284 QRectF ChartLayout::calculateLegendMinimum(const QRectF& geometry,QLegend* legend) const
234 {
285 {
235 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
286 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize,QSizeF(-1,-1));
@@ -264,7 +315,7 QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
264 minimumRect = calculateLegendMinimum(minimumRect, legend);
315 minimumRect = calculateLegendMinimum(minimumRect,legend);
265 minimumRect = calculateAxisMinimum(minimumRect, axes);
316 minimumRect = calculateAxisMinimum(minimumRect,axes);
266 return minimumRect.united(m_minChartRect).size().toSize();
317 return minimumRect.united(m_minChartRect).size().toSize();
267 }
318 }else
268 return QSize(-1, -1);
319 return QSize(-1,-1);
269 }
320 }
270
321
@@ -281,9 +332,4 QMargins ChartLayout::margins() const
281 return m_margins;
332 return m_margins;
282 }
333 }
283
334
284 void ChartLayout::adjustChartGeometry()
285 {
286 setGeometry(geometry());
287 }
288
289 QTCOMMERCIALCHART_END_NAMESPACE
335 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -31,6 +31,7 class ChartTitle;
31 class QLegend;
31 class QLegend;
32 class ChartAxis;
32 class ChartAxis;
33 class ChartBackground;
33 class ChartBackground;
34 class ChartElement;
34
35
35 class ChartLayout : public QGraphicsLayout
36 class ChartLayout : public QGraphicsLayout
36 {
37 {
@@ -43,7 +44,7 public:
43 QMargins margins() const;
44 QMargins margins() const;
44
45
45 void setGeometry(const QRectF &rect);
46 void setGeometry(const QRectF& rect);
46 void adjustChartGeometry();
47 QRectF chartsGeometry() const { return m_chartsRect;}
47
48
48 protected:
49 protected:
49 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
50 QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
@@ -57,6 +58,8 private:
57 QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const;
58 QRectF calculateTitleGeometry(const QRectF& geometry, ChartTitle* title) const;
58 QRectF calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const;
59 QRectF calculateChartGeometry(const QRectF& geometry,const QList<ChartAxis*>& axes) const;
59 QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const;
60 QRectF calculateLegendGeometry(const QRectF& geometry, QLegend* legend) const;
61 QRectF calculateAxisGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const;
62 QRectF calculateChartsGeometry(const QRectF& geometry, const QList<ChartElement*>& charts) const;
60 QRectF calculateBackgroundMinimum(const QRectF &minimum) const;
63 QRectF calculateBackgroundMinimum(const QRectF& minimum) const;
61 QRectF calculateContentMinimum(const QRectF &minimum) const;
64 QRectF calculateContentMinimum(const QRectF& minimum) const;
62 QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const;
65 QRectF calculateTitleMinimum(const QRectF& minimum,ChartTitle* title) const;
@@ -68,6 +71,7 private:
68 QMargins m_margins;
71 QMargins m_margins;
69 QRectF m_minChartRect;
72 QRectF m_minChartRect;
70 QRectF m_minAxisRect;
73 QRectF m_minAxisRect;
74 QRectF m_chartsRect;
71 };
75 };
72
76
73 QTCOMMERCIALCHART_END_NAMESPACE
77 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -35,8 +35,7
35
35
36 QTCOMMERCIALCHART_BEGIN_NAMESPACE
36 QTCOMMERCIALCHART_BEGIN_NAMESPACE
37
37
38 ChartPresenter::ChartPresenter(QChart *chart, ChartDataSet *dataset)
38 ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
39 : QObject(chart),
40 m_chart(chart),
39 m_chart(chart),
41 m_dataset(dataset),
40 m_dataset(dataset),
42 m_chartTheme(0),
41 m_chartTheme(0),
@@ -54,31 +53,15 ChartPresenter::~ChartPresenter()
54 delete m_chartTheme;
53 delete m_chartTheme;
55 }
54 }
56
55
57 void ChartPresenter::setChartsGeometry(const QRectF &rect)
58 {
59 Q_ASSERT(rect.isValid());
60
61 if (m_chartsRect != rect) {
62 m_chartsRect = rect;
63 foreach (ChartElement *chart, m_chartItems)
64 chart->handleGeometryChanged(rect);
65 }
66 }
67
68 QRectF ChartPresenter::chartsGeometry() const
69 {
70 return m_chartsRect;
71 }
72
73 void ChartPresenter::handleAxisAdded(QAbstractAxis *axis, Domain *domain)
56 void ChartPresenter::handleAxisAdded(QAbstractAxis* axis,Domain* domain)
74 {
57 {
75 ChartAxis *item = axis->d_ptr->createGraphics(this);
58 ChartAxis* item = axis->d_ptr->createGraphics(this);
76 item->setDomain(domain);
59 item->setDomain(domain);
77
60
78 if (m_options.testFlag(QChart::GridAxisAnimations))
61 if(m_options.testFlag(QChart::GridAxisAnimations)){
79 item->setAnimation(new AxisAnimation(item));
62 item->setAnimation(new AxisAnimation(item));
63 }
80
64
81 QObject::connect(this, SIGNAL(geometryChanged(QRectF)), item, SLOT(handleGeometryChanged(QRectF)));
82 QObject::connect(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));
65 QObject::connect(domain,SIGNAL(updated()),item,SLOT(handleDomainUpdated()));
83 QObject::connect(axis, SIGNAL(visibleChanged(bool)), this, SLOT(handleAxisVisibleChanged(bool)));
66 QObject::connect(axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleAxisVisibleChanged(bool)));
84
67
@@ -87,11 +70,10 void ChartPresenter::handleAxisAdded(QAbstractAxis *axis, Domain *domain)
87 m_chartTheme->decorate(axis);
70 m_chartTheme->decorate(axis);
88 axis->d_ptr->setDirty(false);
71 axis->d_ptr->setDirty(false);
89 axis->d_ptr->emitUpdated();
72 axis->d_ptr->emitUpdated();
90 if (m_chartsRect.isValid())
91 item->handleGeometryChanged(m_chartsRect);
92
73
93 m_axisItems.insert(axis, item);
74 m_axisItems.insert(axis, item);
94 selectVisibleAxis();
75 selectVisibleAxis();
76 m_layout->invalidate();
95 }
77 }
96
78
97 void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
79 void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
@@ -112,14 +94,12 void ChartPresenter::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
112 Q_ASSERT(item);
94 Q_ASSERT(item);
113 item->setDomain(domain);
95 item->setDomain(domain);
114
96
115 QObject::connect(this, SIGNAL(geometryChanged(QRectF)), item, SLOT(handleGeometryChanged(QRectF)));
116 QObject::connect(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));
97 QObject::connect(domain,SIGNAL(updated()),item,SLOT(handleDomainUpdated()));
117 //initialize
98 //initialize
118 item->handleDomainUpdated();
99 item->handleDomainUpdated();
119
100
120 if (m_chartsRect.isValid())
121 item->handleGeometryChanged(m_chartsRect);
122 m_chartItems.insert(series, item);
101 m_chartItems.insert(series,item);
102 m_layout->invalidate();
123 }
103 }
124
104
125 void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
105 void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
@@ -169,18 +149,19 void ChartPresenter::handleAxisVisibleChanged(bool visible)
169
149
170 while (i.hasNext()) {
150 while (i.hasNext()) {
171 i.next();
151 i.next();
172 if (i.key() == axis)
152 if(i.key()==axis) {
173 continue;
153 continue;
174 if (i.key()->orientation() == axis->orientation())
154 }
155 if(i.key()->orientation()==axis->orientation()) {
175 i.key()->setVisible(false);
156 i.key()->setVisible(false);
176 }
157 }
177 }
158 }
178 }
159 }
160 }
179
161
180 void ChartPresenter::setTheme(QChart::ChartTheme theme, bool force)
162 void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
181 {
163 {
182 if (m_chartTheme && m_chartTheme->id() == theme)
164 if(m_chartTheme && m_chartTheme->id() == theme) return;
183 return;
184 delete m_chartTheme;
165 delete m_chartTheme;
185 m_chartTheme = ChartTheme::createTheme(theme);
166 m_chartTheme = ChartTheme::createTheme(theme);
186 m_chartTheme->setForced(force);
167 m_chartTheme->setForced(force);
@@ -233,23 +214,23 void ChartPresenter::resetAllElements()
233
214
234 void ChartPresenter::zoomIn(qreal factor)
215 void ChartPresenter::zoomIn(qreal factor)
235 {
216 {
236 QRectF rect = chartsGeometry();
217 QRectF rect = m_layout->chartsGeometry();
237 rect.setWidth(rect.width() / factor);
218 rect.setWidth(rect.width()/factor);
238 rect.setHeight(rect.height() / factor);
219 rect.setHeight(rect.height()/factor);
239 rect.moveCenter(chartsGeometry().center());
220 rect.moveCenter(m_layout->chartsGeometry().center());
240 zoomIn(rect);
221 zoomIn(rect);
241 }
222 }
242
223
243 void ChartPresenter::zoomIn(const QRectF &rect)
224 void ChartPresenter::zoomIn(const QRectF& rect)
244 {
225 {
245 QRectF r = rect.normalized();
226 QRectF r = rect.normalized();
246 r.translate(-chartsGeometry().topLeft());
227 r.translate(-m_layout->chartsGeometry().topLeft());
247 if (!r.isValid())
228 if (!r.isValid())
248 return;
229 return;
249
230
250 m_state = ZoomInState;
231 m_state = ZoomInState;
251 m_statePoint = QPointF(r.center().x() / chartsGeometry().width(), r.center().y() / chartsGeometry().height());
232 m_statePoint = QPointF(r.center().x()/m_layout->chartsGeometry().width(),r.center().y()/m_layout->chartsGeometry().height());
252 m_dataset->zoomInDomain(r, chartsGeometry().size());
233 m_dataset->zoomInDomain(r,m_layout->chartsGeometry().size());
253 m_state = ShowState;
234 m_state = ShowState;
254 }
235 }
255
236
@@ -258,14 +239,14 void ChartPresenter::zoomOut(qreal factor)
258 m_state = ZoomOutState;
239 m_state = ZoomOutState;
259
240
260 QRectF chartRect;
241 QRectF chartRect;
261 chartRect.setSize(chartsGeometry().size());
242 chartRect.setSize(m_layout->chartsGeometry().size());
262
243
263 QRectF rect;
244 QRectF rect;
264 rect.setSize(chartRect.size() / factor);
245 rect.setSize(chartRect.size()/factor);
265 rect.moveCenter(chartRect.center());
246 rect.moveCenter(chartRect.center());
266 if (!rect.isValid())
247 if (!rect.isValid())
267 return;
248 return;
268 m_statePoint = QPointF(rect.center().x() / chartsGeometry().width(), rect.center().y() / chartsGeometry().height());
249 m_statePoint = QPointF(rect.center().x()/m_layout->chartsGeometry().width(),rect.center().y()/m_layout->chartsGeometry().height());
269 m_dataset->zoomOutDomain(rect, chartRect.size());
250 m_dataset->zoomOutDomain(rect, chartRect.size());
270 m_state = ShowState;
251 m_state = ShowState;
271 }
252 }
@@ -277,7 +258,7 void ChartPresenter::scroll(qreal dx, qreal dy)
277 if (dy < 0) m_state = ScrollUpState;
258 if(dy<0) m_state=ScrollUpState;
278 if (dy > 0) m_state = ScrollDownState;
259 if(dy>0) m_state=ScrollDownState;
279
260
280 m_dataset->scrollDomain(dx, dy, chartsGeometry().size());
261 m_dataset->scrollDomain(dx,dy,m_layout->chartsGeometry().size());
281 m_state = ShowState;
262 m_state = ShowState;
282 }
263 }
283
264
@@ -307,17 +288,16 void ChartPresenter::createTitleItem()
307 void ChartPresenter::handleAnimationFinished()
288 void ChartPresenter::handleAnimationFinished()
308 {
289 {
309 m_animations.removeAll(qobject_cast<ChartAnimation *>(sender()));
290 m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
310 if (m_animations.empty())
291 if(m_animations.empty()) emit animationsFinished();
311 emit animationsFinished();
312 }
292 }
313
293
314 void ChartPresenter::startAnimation(ChartAnimation *animation)
294 void ChartPresenter::startAnimation(ChartAnimation* animation)
315 {
295 {
316 if (animation->state() != QAbstractAnimation::Stopped)
296 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
317 animation->stop();
318 QObject::connect(animation, SIGNAL(finished()), this, SLOT(handleAnimationFinished()), Qt::UniqueConnection);
297 QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
319 if (!m_animations.isEmpty())
298 if(!m_animations.isEmpty()){
320 m_animations.append(animation);
299 m_animations.append(animation);
300 }
321 QTimer::singleShot(0, animation, SLOT(start()));
301 QTimer::singleShot(0, animation, SLOT(start()));
322 }
302 }
323
303
@@ -330,8 +310,7 void ChartPresenter::setBackgroundBrush(const QBrush &brush)
330
310
331 QBrush ChartPresenter::backgroundBrush() const
311 QBrush ChartPresenter::backgroundBrush() const
332 {
312 {
333 if (!m_background)
313 if (!m_background) return QBrush();
334 return QBrush();
335 return m_background->brush();
314 return m_background->brush();
336 }
315 }
337
316
@@ -344,8 +323,7 void ChartPresenter::setBackgroundPen(const QPen &pen)
344
323
345 QPen ChartPresenter::backgroundPen() const
324 QPen ChartPresenter::backgroundPen() const
346 {
325 {
347 if (!m_background)
326 if (!m_background) return QPen();
348 return QPen();
349 return m_background->pen();
327 return m_background->pen();
350 }
328 }
351
329
@@ -358,8 +336,7 void ChartPresenter::setTitle(const QString &title)
358
336
359 QString ChartPresenter::title() const
337 QString ChartPresenter::title() const
360 {
338 {
361 if (!m_title)
339 if (!m_title) return QString();
362 return QString();
363 return m_title->text();
340 return m_title->text();
364 }
341 }
365
342
@@ -372,8 +349,7 void ChartPresenter::setTitleFont(const QFont &font)
372
349
373 QFont ChartPresenter::titleFont() const
350 QFont ChartPresenter::titleFont() const
374 {
351 {
375 if (!m_title)
352 if (!m_title) return QFont();
376 return QFont();
377 return m_title->font();
353 return m_title->font();
378 }
354 }
379
355
@@ -386,8 +362,7 void ChartPresenter::setTitleBrush(const QBrush &brush)
386
362
387 QBrush ChartPresenter::titleBrush() const
363 QBrush ChartPresenter::titleBrush() const
388 {
364 {
389 if (!m_title)
365 if (!m_title) return QBrush();
390 return QBrush();
391 return m_title->brush();
366 return m_title->brush();
392 }
367 }
393
368
@@ -400,8 +375,7 void ChartPresenter::setBackgroundVisible(bool visible)
400
375
401 bool ChartPresenter::isBackgroundVisible() const
376 bool ChartPresenter::isBackgroundVisible() const
402 {
377 {
403 if (!m_background)
378 if (!m_background) return false;
404 return false;
405 return m_background->isVisible();
379 return m_background->isVisible();
406 }
380 }
407
381
@@ -413,27 +387,16 void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
413
387
414 bool ChartPresenter::isBackgroundDropShadowEnabled() const
388 bool ChartPresenter::isBackgroundDropShadowEnabled() const
415 {
389 {
416 if (!m_background)
390 if (!m_background) return false;
417 return false;
418 return m_background->isDropShadowEnabled();
391 return m_background->isDropShadowEnabled();
419 }
392 }
420
393
421
394
422 QGraphicsLayout *ChartPresenter::layout()
395 ChartLayout* ChartPresenter::layout()
423 {
396 {
424 return m_layout;
397 return m_layout;
425 }
398 }
426
399
427 void ChartPresenter::setMargins(const QMargins &margins)
428 {
429 m_layout->setMargins(margins);
430 }
431
432 QMargins ChartPresenter::margins() const
433 {
434 return m_layout->margins();
435 }
436
437 QLegend *ChartPresenter::legend()
400 QLegend* ChartPresenter::legend()
438 {
401 {
439 return m_chart->legend();
402 return m_chart->legend();
@@ -454,6 +417,11 QList<ChartAxis *> ChartPresenter::axisItems() const
454 return m_axisItems.values();
417 return m_axisItems.values();
455 }
418 }
456
419
420 QList<ChartElement*> ChartPresenter::chartItems() const
421 {
422 return m_chartItems.values();
423 }
424
457 ChartTitle *ChartPresenter::titleElement()
425 ChartTitle* ChartPresenter::titleElement()
458 {
426 {
459 return m_title;
427 return m_title;
Show file before | Show file after | Hide comments
@@ -87,6 +87,7 public:
87 ChartBackground *backgroundElement();
87 ChartBackground* backgroundElement();
88 ChartTitle *titleElement();
88 ChartTitle* titleElement();
89 QList<ChartAxis *> axisItems() const;
89 QList<ChartAxis*> axisItems() const;
90 QList<ChartElement*> chartItems() const;
90
91
91 QLegend *legend();
92 QLegend* legend();
92
93
@@ -124,18 +125,13 public:
124 void zoomOut(qreal factor);
125 void zoomOut(qreal factor);
125 void scroll(qreal dx, qreal dy);
126 void scroll(qreal dx,qreal dy);
126
127
127 void setChartsGeometry(const QRectF &rect);
128 QRectF chartsGeometry() const;
129
130 void startAnimation(ChartAnimation *animation);
128 void startAnimation(ChartAnimation* animation);
131 State state() const { return m_state; }
129 State state() const { return m_state; }
132 QPointF statePoint() const { return m_statePoint; }
130 QPointF statePoint() const { return m_statePoint; }
133
131
134 void resetAllElements();
132 void resetAllElements();
135
133
136 void setMargins(const QMargins &margins);
134 ChartLayout* layout();
137 QMargins margins() const;
138 QGraphicsLayout *layout();
139
135
140 private:
136 private:
141 void createBackgroundItem();
137 void createBackgroundItem();
@@ -153,9 +149,7 private Q_SLOTS:
153 void handleAnimationFinished();
149 void handleAnimationFinished();
154
150
155 Q_SIGNALS:
151 Q_SIGNALS:
156 void geometryChanged(const QRectF &rect);
157 void animationsFinished();
152 void animationsFinished();
158 void marginsChanged(QRectF margins);
159
153
160 private:
154 private:
161 QChart *m_chart;
155 QChart* m_chart;
@@ -163,7 +157,6 private:
163 ChartTheme *m_chartTheme;
157 ChartTheme *m_chartTheme;
164 QMap<QAbstractSeries *, ChartElement *> m_chartItems;
158 QMap<QAbstractSeries*, ChartElement*> m_chartItems;
165 QMap<QAbstractAxis *, ChartAxis *> m_axisItems;
159 QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
166 QRectF m_chartsRect;
167 QChart::AnimationOptions m_options;
160 QChart::AnimationOptions m_options;
168 State m_state;
161 State m_state;
169 QPointF m_statePoint;
162 QPointF m_statePoint;
Show file before | Show file after | Hide comments
@@ -22,7 +22,7
22 #include "chartpresenter_p.h"
22 #include "chartpresenter_p.h"
23 #include "legendmarker_p.h"
23 #include "legendmarker_p.h"
24 #include "qlegend_p.h"
24 #include "qlegend_p.h"
25 #include <QDebug>
25 #include "chartlayout_p.h"
26
26
27 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 QTCOMMERCIALCHART_BEGIN_NAMESPACE
28
28
Show file before | Show file after | Hide comments
@@ -38,10 +38,10
38 #include "qpieseries_p.h"
38 #include "qpieseries_p.h"
39 #include "qpieslice.h"
39 #include "qpieslice.h"
40 #include "chartpresenter_p.h"
40 #include "chartpresenter_p.h"
41 #include "chartlayout_p.h"
41 #include <QPainter>
42 #include <QPainter>
42 #include <QPen>
43 #include <QPen>
43 #include <QTimer>
44 #include <QTimer>
44 #include <QGraphicsLayout>
45 #include <QGraphicsSceneEvent>
45 #include <QGraphicsSceneEvent>
46
46
47 QTCOMMERCIALCHART_BEGIN_NAMESPACE
47 QTCOMMERCIALCHART_BEGIN_NAMESPACE
Show file before | Show file after | Hide comments
@@ -24,9 +24,9
24 #include "qlegend_p.h"
24 #include "qlegend_p.h"
25 #include "chartbackground_p.h"
25 #include "chartbackground_p.h"
26 #include "qabstractaxis.h"
26 #include "qabstractaxis.h"
27 #include "chartlayout_p.h"
27 #include <QGraphicsScene>
28 #include <QGraphicsScene>
28 #include <QGraphicsSceneResizeEvent>
29 #include <QGraphicsSceneResizeEvent>
29 #include <QGraphicsLayout>
30
30
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32
32
@@ -104,8 +104,7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
104 /*!
104 /*!
105 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
105 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
106 */
106 */
107 QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
107 QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
108 : QGraphicsWidget(parent, wFlags),
109 d_ptr(new QChartPrivate())
108 d_ptr(new QChartPrivate())
110 {
109 {
111 d_ptr->m_dataset = new ChartDataSet(this);
110 d_ptr->m_dataset = new ChartDataSet(this);
@@ -266,8 +265,7 void QChart::zoomIn()
266 */
265 */
267 void QChart::zoomIn(const QRectF &rect)
266 void QChart::zoomIn(const QRectF& rect)
268 {
267 {
269 if (!rect.isValid())
268 if (!rect.isValid()) return;
270 return;
271 d_ptr->m_presenter->zoomIn(rect);
269 d_ptr->m_presenter->zoomIn(rect);
272 }
270 }
273
271
@@ -371,7 +369,7 QLegend *QChart::legend() const
371 */
369 */
372 void QChart::setMargins(const QMargins &margins)
370 void QChart::setMargins(const QMargins& margins)
373 {
371 {
374 d_ptr->m_presenter->setMargins(margins);
372 d_ptr->m_presenter->layout()->setMargins(margins);
375 }
373 }
376
374
377 /*!
375 /*!
@@ -380,7 +378,7 void QChart::setMargins(const QMargins &margins)
380 */
378 */
381 QMargins QChart::margins() const
379 QMargins QChart::margins() const
382 {
380 {
383 return d_ptr->m_presenter->margins();
381 return d_ptr->m_presenter->layout()->margins();
384 }
382 }
385
383
386 /*!
384 /*!
@@ -389,7 +387,7 QMargins QChart::margins() const
389 */
387 */
390 QRectF QChart::plotArea() const
388 QRectF QChart::plotArea() const
391 {
389 {
392 return d_ptr->m_presenter->chartsGeometry();
390 return d_ptr->m_presenter->layout()->chartsGeometry();
393 }
391 }
394
392
395 ///*!
393 ///*!
@@ -459,6 +457,7 QList<QAbstractSeries *> QChart::series() const
459 */
457 */
460 void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
458 void QChart::setAxisX(QAbstractAxis* axis , QAbstractSeries *series)
461 {
459 {
460 if(axis->alignment()==Qt::AlignLeft || axis->alignment()==Qt::AlignRight) return;
462 d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal);
461 d_ptr->m_dataset->setAxis(series,axis,Qt::Horizontal);
463 }
462 }
464
463
@@ -469,6 +468,7 void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
469 */
468 */
470 void QChart::setAxisY(QAbstractAxis *axis , QAbstractSeries *series)
469 void QChart::setAxisY( QAbstractAxis* axis , QAbstractSeries *series)
471 {
470 {
471 if(axis->alignment()==Qt::AlignTop || axis->alignment()==Qt::AlignBottom) return;
472 d_ptr->m_dataset->setAxis(series, axis, Qt::Vertical);
472 d_ptr->m_dataset->setAxis(series,axis,Qt::Vertical);
473 }
473 }
474
474
General Comments 0
You need to be logged in to leave comments. Login now