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

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

Added missing properties and NOTIFY's to logvalue and value axes
Marek Rosa -
r2319:0473979ecc50
parent child
Show More
Side by Side Unified
Context file:
r2319:0473979ecc50 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,324 +1,325
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "qlogvalueaxis.h"
22 22 #include "qlogvalueaxis_p.h"
23 23 #include "chartlogvalueaxisx_p.h"
24 24 #include "chartlogvalueaxisy_p.h"
25 25 #include "abstractdomain_p.h"
26 26 #include <float.h>
27 27 #include <cmath>
28 28
29 29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 30 /*!
31 31 \class QLogValueAxis
32 32 \brief The QLogValueAxis class is used for manipulating chart's axis.
33 33 \mainclass
34 34 */
35 35
36 36 /*!
37 37 \qmlclass DateTimeAxis QLogValueAxis
38 38 \brief The DateTimeAxis element is used for manipulating chart's axes
39 39 \inherits AbstractAxis
40 40 */
41 41
42 42 /*!
43 43 \property QLogValueAxis::min
44 44 Defines the minimum value on the axis.
45 45 When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
46 46 */
47 47 /*!
48 48 \qmlproperty real ValuesAxis::min
49 49 Defines the minimum value on the axis.
50 50 When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
51 51 */
52 52
53 53 /*!
54 54 \property QLogValueAxis::max
55 55 Defines the maximum value on the axis.
56 56 When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
57 57 */
58 58 /*!
59 59 \qmlproperty real ValuesAxis::max
60 60 Defines the maximum value on the axis.
61 61 When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
62 62 */
63 63
64 64 /*!
65 65 \fn void QLogValueAxis::minChanged(qreal min)
66 66 Axis emits signal when \a min of axis has changed.
67 67 */
68 68 /*!
69 69 \qmlsignal ValuesAxis::onMinChanged(qreal min)
70 70 Axis emits signal when \a min of axis has changed.
71 71 */
72 72
73 73 /*!
74 74 \fn void QLogValueAxis::maxChanged(qreal max)
75 75 Axis emits signal when \a max of axis has changed.
76 76 */
77 77 /*!
78 78 \qmlsignal ValuesAxis::onMaxChanged(qreal max)
79 79 Axis emits signal when \a max of axis has changed.
80 80 */
81 81
82 82 /*!
83 83 \fn void QLogValueAxis::rangeChanged(qreal min, qreal max)
84 84 Axis emits signal when \a min or \a max of axis has changed.
85 85 */
86 86
87 87 /*!
88 88 Constructs an axis object which is a child of \a parent.
89 89 */
90 90 QLogValueAxis::QLogValueAxis(QObject *parent) :
91 91 QAbstractAxis(*new QLogValueAxisPrivate(this), parent)
92 92 {
93 93
94 94 }
95 95
96 96 /*!
97 97 \internal
98 98 */
99 99 QLogValueAxis::QLogValueAxis(QLogValueAxisPrivate &d, QObject *parent) : QAbstractAxis(d, parent)
100 100 {
101 101
102 102 }
103 103
104 104 /*!
105 105 Destroys the object
106 106 */
107 107 QLogValueAxis::~QLogValueAxis()
108 108 {
109 109 Q_D(QLogValueAxis);
110 110 if (d->m_chart)
111 111 d->m_chart->removeAxis(this);
112 112 }
113 113
114 114 void QLogValueAxis::setMin(qreal min)
115 115 {
116 116 Q_D(QLogValueAxis);
117 117 setRange(min, qMax(d->m_max, min));
118 118 }
119 119
120 120 qreal QLogValueAxis::min() const
121 121 {
122 122 Q_D(const QLogValueAxis);
123 123 return d->m_min;
124 124 }
125 125
126 126 void QLogValueAxis::setMax(qreal max)
127 127 {
128 128 Q_D(QLogValueAxis);
129 129 setRange(qMin(d->m_min, max), max);
130 130 }
131 131
132 132 qreal QLogValueAxis::max() const
133 133 {
134 134 Q_D(const QLogValueAxis);
135 135 return d->m_max;
136 136 }
137 137
138 138 /*!
139 139 Sets range from \a min to \a max on the axis.
140 140 If min is greater than max then this function returns without making any changes.
141 141 */
142 142 void QLogValueAxis::setRange(qreal min, qreal max)
143 143 {
144 144 Q_D(QLogValueAxis);
145 145 bool changed = false;
146 146
147 147 if (min > max)
148 148 return;
149 149
150 150 if (min > 0) {
151 151 if (!qFuzzyCompare(d->m_min, min)) {
152 152 d->m_min = min;
153 153 changed = true;
154 154 emit minChanged(min);
155 155 }
156 156
157 157 if (!qFuzzyCompare(d->m_max, max)) {
158 158 d->m_max = max;
159 159 changed = true;
160 160 emit maxChanged(max);
161 161 }
162 162
163 163 if (changed) {
164 164 emit rangeChanged(min, max);
165 165 emit d->rangeChanged(min,max);
166 166 }
167 167 }
168 168 }
169 169
170 170 void QLogValueAxis::setLabelFormat(const QString &format)
171 171 {
172 172 Q_D(QLogValueAxis);
173 173 d->m_format = format;
174 emit labelFormatChanged(format);
174 175 }
175 176
176 177 QString QLogValueAxis::labelFormat() const
177 178 {
178 179 Q_D(const QLogValueAxis);
179 180 return d->m_format;
180 181 }
181 182
182 183 void QLogValueAxis::setBase(qreal base)
183 184 {
184 185 // check if base is correct
185 186 if (qFuzzyCompare(base, 1))
186 187 return;
187 188
188 189 if (base > 0) {
189 190 Q_D(QLogValueAxis);
190 191 d->m_base = base;
191 192 emit baseChanged(base);
192 193 }
193 194 }
194 195
195 196 qreal QLogValueAxis::base() const
196 197 {
197 198 Q_D(const QLogValueAxis);
198 199 return d->m_base;
199 200 }
200 201
201 202 /*!
202 203 Returns the type of the axis
203 204 */
204 205 QAbstractAxis::AxisType QLogValueAxis::type() const
205 206 {
206 207 return AxisTypeLogValue;
207 208 }
208 209
209 210 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
210 211
211 212 QLogValueAxisPrivate::QLogValueAxisPrivate(QLogValueAxis *q)
212 213 : QAbstractAxisPrivate(q),
213 214 m_min(1),
214 215 m_max(1),
215 216 m_base(10),
216 217 m_format(QString::null)
217 218 {
218 219 }
219 220
220 221 QLogValueAxisPrivate::~QLogValueAxisPrivate()
221 222 {
222 223
223 224 }
224 225
225 226 void QLogValueAxisPrivate::setMin(const QVariant &min)
226 227 {
227 228 Q_Q(QLogValueAxis);
228 229 bool ok;
229 230 qreal value = min.toReal(&ok);
230 231 if (ok)
231 232 q->setMin(value);
232 233 }
233 234
234 235 void QLogValueAxisPrivate::setMax(const QVariant &max)
235 236 {
236 237
237 238 Q_Q(QLogValueAxis);
238 239 bool ok;
239 240 qreal value = max.toReal(&ok);
240 241 if (ok)
241 242 q->setMax(value);
242 243 }
243 244
244 245 void QLogValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
245 246 {
246 247 Q_Q(QLogValueAxis);
247 248 bool ok1;
248 249 bool ok2;
249 250 qreal value1 = min.toReal(&ok1);
250 251 qreal value2 = max.toReal(&ok2);
251 252 if (ok1 && ok2)
252 253 q->setRange(value1, value2);
253 254 }
254 255
255 256 void QLogValueAxisPrivate::setRange(qreal min, qreal max)
256 257 {
257 258 Q_Q(QLogValueAxis);
258 259 bool changed = false;
259 260
260 261 if (min > max)
261 262 return;
262 263
263 264 if (min > 0) {
264 265 if (!qFuzzyCompare(m_min, min)) {
265 266 m_min = min;
266 267 changed = true;
267 268 emit q->minChanged(min);
268 269 }
269 270
270 271 if (!qFuzzyCompare(m_max, max)) {
271 272 m_max = max;
272 273 changed = true;
273 274 emit q->maxChanged(max);
274 275 }
275 276
276 277 if (changed) {
277 278 emit q->rangeChanged(min, max);
278 279 emit rangeChanged(min,max);
279 280 }
280 281 }
281 282 }
282 283
283 284 void QLogValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
284 285 {
285 286 Q_Q(QLogValueAxis);
286 287 ChartAxis* axis(0);
287 288 if (orientation() == Qt::Vertical)
288 289 axis = new ChartLogValueAxisY(q,parent);
289 290 if (orientation() == Qt::Horizontal)
290 291 axis = new ChartLogValueAxisX(q,parent);
291 292
292 293 m_item.reset(axis);
293 294 QAbstractAxisPrivate::initializeGraphics(parent);
294 295 }
295 296
296 297
297 298 void QLogValueAxisPrivate::initializeDomain(AbstractDomain *domain)
298 299 {
299 300 if (orientation() == Qt::Vertical) {
300 301 if(!qFuzzyCompare(m_max, m_min)) {
301 302 domain->setRangeY(m_min, m_max);
302 303 }
303 304 else if ( domain->minY() > 0) {
304 305 setRange(domain->minY(), domain->maxY());
305 306 } else {
306 307 domain->setRangeY(m_min, domain->maxY());
307 308 }
308 309 }
309 310 if (orientation() == Qt::Horizontal) {
310 311 if(!qFuzzyCompare(m_max, m_min)) {
311 312 domain->setRangeX(m_min, m_max);
312 313 }
313 314 else if (domain->minX() > 0){
314 315 setRange(domain->minX(), domain->maxX());
315 316 } else {
316 317 domain->setRangeX(m_min, domain->maxX());
317 318 }
318 319 }
319 320 }
320 321
321 322 #include "moc_qlogvalueaxis.cpp"
322 323 #include "moc_qlogvalueaxis_p.cpp"
323 324
324 325 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,75 +1,77
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #ifndef QLOGVALUEAXIS_H
22 22 #define QLOGVALUEAXIS_H
23 23
24 24 #include "qabstractaxis.h"
25 25
26 26 class QDateTime;
27 27
28 28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29 29
30 30 class QLogValueAxisPrivate;
31 31
32 32 class QTCOMMERCIALCHART_EXPORT QLogValueAxis : public QAbstractAxis
33 33 {
34 34 Q_OBJECT
35 35 Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
36 36 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
37 Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat)
37 Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat NOTIFY labelFormatChanged)
38 Q_PROPERTY(qreal base READ base WRITE setBase NOTIFY baseChanged)
38 39
39 40 public:
40 41 explicit QLogValueAxis(QObject *parent = 0);
41 42 ~QLogValueAxis();
42 43
43 44 protected:
44 45 QLogValueAxis(QLogValueAxisPrivate &d, QObject *parent = 0);
45 46
46 47 public:
47 48 AxisType type() const;
48 49
49 50 //range handling
50 51 void setMin(qreal min);
51 52 qreal min() const;
52 53 void setMax(qreal max);
53 54 qreal max() const;
54 55 void setRange(qreal min, qreal max);
55 56
56 57 void setLabelFormat(const QString &format);
57 58 QString labelFormat() const;
58 59
59 60 void setBase(qreal base);
60 61 qreal base() const;
61 62
62 63 Q_SIGNALS:
63 64 void minChanged(qreal min);
64 65 void maxChanged(qreal max);
65 66 void rangeChanged(qreal min, qreal max);
67 void labelFormatChanged(const QString &format);
66 68 void baseChanged(qreal base);
67 69
68 70 private:
69 71 Q_DECLARE_PRIVATE(QLogValueAxis)
70 72 Q_DISABLE_COPY(QLogValueAxis)
71 73 };
72 74
73 75 QTCOMMERCIALCHART_END_NAMESPACE
74 76
75 77 #endif // QLOGVALUEAXIS_H
Show file before | Show file after | Hide comments
@@ -1,409 +1,410
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include "qvalueaxis.h"
22 22 #include "qvalueaxis_p.h"
23 23 #include "chartvalueaxisx_p.h"
24 24 #include "chartvalueaxisy_p.h"
25 25 #include "abstractdomain_p.h"
26 26 #include "chartdataset_p.h"
27 27 #include "chartpresenter_p.h"
28 28 #include "charttheme_p.h"
29 29
30 30
31 31 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32 32 /*!
33 33 \class QValueAxis
34 34 \brief The QValueAxis class is used for manipulating chart's axis.
35 35 \mainclass
36 36
37 37 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
38 38 Values of axis are drawn to position of ticks.
39 39
40 40 Example code on how to use QValueAxis.
41 41 \code
42 42 QChartView *chartView = new QChartView;
43 43 QLineSeries *series = new QLineSeries;
44 44 // ...
45 45 chartView->chart()->addSeries(series);
46 46
47 47 QValueAxis *axisX = new QValueAxis;
48 48 axisX->setRange(10, 20.5);
49 49 axisX->setTickCount(10);
50 50 axisX->setLabelFormat("%.2f");
51 51 chartView->chart()->setAxisX(axisX, series);
52 52 \endcode
53 53 */
54 54
55 55 /*!
56 56 \qmlclass ValueAxis QValueAxis
57 57 \inherits AbstractAxis
58 58 \brief The ValueAxis element is used for manipulating chart's axes
59 59
60 60 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
61 61 Values of axis are drawn to position of ticks
62 62
63 63 To access Axes you can use ChartView API. For example:
64 64 \code
65 65 ChartView {
66 66 ValueAxis {
67 67 id: xAxis
68 68 min: 0
69 69 max: 10
70 70 }
71 71 // Add a few series...
72 72 }
73 73 \endcode
74 74 */
75 75
76 76 /*!
77 77 \property QValueAxis::min
78 78 Defines the minimum value on the axis.
79 79 When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
80 80 */
81 81 /*!
82 82 \qmlproperty real ValueAxis::min
83 83 Defines the minimum value on the axis.
84 84 When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
85 85 */
86 86
87 87 /*!
88 88 \property QValueAxis::max
89 89 Defines the maximum value on the axis.
90 90 When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
91 91 */
92 92 /*!
93 93 \qmlproperty real ValueAxis::max
94 94 Defines the maximum value on the axis.
95 95 When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
96 96 */
97 97
98 98 /*!
99 99 \property QValueAxis::tickCount
100 100 Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
101 101 The default value is 5, and it can not be below 2.
102 102 */
103 103 /*!
104 104 \qmlproperty real ValueAxis::tickCount
105 105 Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
106 106 The default value is 5, and it can not be below 2.
107 107 */
108 108
109 109 /*!
110 110 \property QValueAxis::labelFormat
111 111 Defines the label format for the axis.
112 112 Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
113 113 See QString::sprintf() for additional details.
114 114 */
115 115 /*!
116 116 \qmlproperty real ValueAxis::labelFormat
117 117 Defines the label format for the axis.
118 118 Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
119 119 See QString::sprintf() for additional details.
120 120 */
121 121
122 122 /*!
123 123 \fn void QValueAxis::minChanged(qreal min)
124 124 Axis emits signal when \a min of axis has changed.
125 125 */
126 126 /*!
127 127 \qmlsignal ValueAxis::onMinChanged(real min)
128 128 Axis emits signal when \a min of axis has changed.
129 129 */
130 130
131 131 /*!
132 132 \fn void QValueAxis::maxChanged(qreal max)
133 133 Axis emits signal when \a max of axis has changed.
134 134 */
135 135 /*!
136 136 \qmlsignal ValueAxis::onMaxChanged(real max)
137 137 Axis emits signal when \a max of axis has changed.
138 138 */
139 139
140 140 /*!
141 141 \fn void QValueAxis::tickCountChanged(int tickCount)
142 142 Axis emits signal when number of ticks on axis have changed.
143 143 */
144 144 /*!
145 145 \qmlsignal ValueAxis::tickCountChanged(int tickCount)
146 146 Axis emits signal when number of ticks on axis have changed.
147 147 */
148 148
149 149 /*!
150 150 \fn void QValueAxis::rangeChanged(qreal min, qreal max)
151 151 Axis emits signal when \a min or \a max of axis has changed.
152 152 */
153 153
154 154 /*!
155 155 \property QValueAxis::niceNumbersEnabled
156 156 Whether the nice numbers algorithm is enabled or not for the axis.
157 157 */
158 158
159 159 /*!
160 160 \qmlproperty bool ValueAxis::niceNumbersEnabled
161 161 Whether the nice numbers algorithm is enabled or not for the axis.
162 162 */
163 163
164 164 /*!
165 165 Constructs an axis object which is a child of \a parent.
166 166 */
167 167 QValueAxis::QValueAxis(QObject *parent) :
168 168 QAbstractAxis(*new QValueAxisPrivate(this), parent)
169 169 {
170 170
171 171 }
172 172
173 173 /*!
174 174 \internal
175 175 */
176 176 QValueAxis::QValueAxis(QValueAxisPrivate &d, QObject *parent)
177 177 : QAbstractAxis(d, parent)
178 178 {
179 179
180 180 }
181 181
182 182 /*!
183 183 Destroys the object
184 184 */
185 185 QValueAxis::~QValueAxis()
186 186 {
187 187 Q_D(QValueAxis);
188 188 if (d->m_chart)
189 189 d->m_chart->removeAxis(this);
190 190 }
191 191
192 192 void QValueAxis::setMin(qreal min)
193 193 {
194 194 Q_D(QValueAxis);
195 195 setRange(min, qMax(d->m_max, min));
196 196 }
197 197
198 198 qreal QValueAxis::min() const
199 199 {
200 200 Q_D(const QValueAxis);
201 201 return d->m_min;
202 202 }
203 203
204 204 void QValueAxis::setMax(qreal max)
205 205 {
206 206 Q_D(QValueAxis);
207 207 setRange(qMin(d->m_min, max), max);
208 208 }
209 209
210 210 qreal QValueAxis::max() const
211 211 {
212 212 Q_D(const QValueAxis);
213 213 return d->m_max;
214 214 }
215 215
216 216 /*!
217 217 Sets range from \a min to \a max on the axis.
218 218 If min is greater than max then this function returns without making any changes.
219 219 */
220 220 void QValueAxis::setRange(qreal min, qreal max)
221 221 {
222 222 Q_D(QValueAxis);
223 223 d->setRange(min,max);
224 224 }
225 225
226 226 void QValueAxis::setTickCount(int count)
227 227 {
228 228 Q_D(QValueAxis);
229 229 if (d->m_tickCount != count && count >= 2) {
230 230 d->m_tickCount = count;
231 231 emit tickCountChanged(count);
232 232 }
233 233 }
234 234
235 235 int QValueAxis::tickCount() const
236 236 {
237 237 Q_D(const QValueAxis);
238 238 return d->m_tickCount;
239 239 }
240 240
241 241 void QValueAxis::setNiceNumbersEnabled(bool enable)
242 242 {
243 243 Q_D(QValueAxis);
244 244 qWarning()<<"This function is depreciated, it can lead to unexpected behaviour.Use applyNiceNumbers(). ";
245 245 if(enable) {
246 246 QObject::connect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
247 247 QObject::connect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
248 248 applyNiceNumbers();
249 249 }
250 250 else {
251 251 QObject::disconnect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
252 252 QObject::disconnect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
253 253 }
254 254 d->m_niceNumbersEnabled=enable;
255 255 }
256 256
257 257 bool QValueAxis::niceNumbersEnabled() const
258 258 {
259 259 Q_D(const QValueAxis);
260 260 qWarning()<<"This function is depreciated.Use applyNiceNumbers().";
261 261 return d->m_niceNumbersEnabled;
262 262 }
263 263
264 264 void QValueAxis::setLabelFormat(const QString &format)
265 265 {
266 266 Q_D(QValueAxis);
267 267 d->m_format = format;
268 emit labelFormatChanged(format);
268 269 }
269 270
270 271 QString QValueAxis::labelFormat() const
271 272 {
272 273 Q_D(const QValueAxis);
273 274 return d->m_format;
274 275 }
275 276
276 277 /*!
277 278 Returns the type of the axis
278 279 */
279 280 QAbstractAxis::AxisType QValueAxis::type() const
280 281 {
281 282 return AxisTypeValue;
282 283 }
283 284
284 285 void QValueAxis::applyNiceNumbers()
285 286 {
286 287 Q_D(QValueAxis);
287 288 if(d->m_applying) return;
288 289 qreal min = d->m_min;
289 290 qreal max = d->m_max;
290 291 int ticks = d->m_tickCount;
291 292 AbstractDomain::looseNiceNumbers(min,max,ticks);
292 293 d->m_applying=true;
293 294 d->setRange(min,max);
294 295 setTickCount(ticks);
295 296 d->m_applying=false;
296 297 }
297 298
298 299 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
299 300
300 301 QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
301 302 : QAbstractAxisPrivate(q),
302 303 m_min(0),
303 304 m_max(0),
304 305 m_tickCount(5),
305 306 m_format(QString::null),
306 307 m_applying(false),
307 308 m_niceNumbersEnabled(false)
308 309 {
309 310
310 311 }
311 312
312 313 QValueAxisPrivate::~QValueAxisPrivate()
313 314 {
314 315
315 316 }
316 317
317 318 void QValueAxisPrivate::setMin(const QVariant &min)
318 319 {
319 320 Q_Q(QValueAxis);
320 321 bool ok;
321 322 qreal value = min.toReal(&ok);
322 323 if (ok)
323 324 q->setMin(value);
324 325 }
325 326
326 327 void QValueAxisPrivate::setMax(const QVariant &max)
327 328 {
328 329 Q_Q(QValueAxis);
329 330 bool ok;
330 331 qreal value = max.toReal(&ok);
331 332 if (ok)
332 333 q->setMax(value);
333 334 }
334 335
335 336 void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
336 337 {
337 338 Q_Q(QValueAxis);
338 339 bool ok1;
339 340 bool ok2;
340 341 qreal value1 = min.toReal(&ok1);
341 342 qreal value2 = max.toReal(&ok2);
342 343 if (ok1 && ok2)
343 344 q->setRange(value1, value2);
344 345 }
345 346
346 347 void QValueAxisPrivate::setRange(qreal min, qreal max)
347 348 {
348 349 Q_Q(QValueAxis);
349 350 bool changed = false;
350 351
351 352 if (min > max)
352 353 return;
353 354
354 355 if (!qFuzzyCompare(m_min,min)) {
355 356 m_min = min;
356 357 changed = true;
357 358 emit q->minChanged(min);
358 359 }
359 360
360 361 if (!qFuzzyCompare(m_max,max)) {
361 362 m_max = max;
362 363 changed = true;
363 364 emit q->maxChanged(max);
364 365 }
365 366
366 367 if (changed) {
367 368 emit rangeChanged(min,max);
368 369 emit q->rangeChanged(min, max);
369 370 }
370 371 }
371 372
372 373 void QValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
373 374 {
374 375 Q_Q(QValueAxis);
375 376 ChartAxis* axis(0);
376 377 if (orientation() == Qt::Vertical)
377 378 axis = new ChartValueAxisY(q,parent);
378 379 if (orientation() == Qt::Horizontal)
379 380 axis = new ChartValueAxisX(q,parent);
380 381
381 382 m_item.reset(axis);
382 383 QAbstractAxisPrivate::initializeGraphics(parent);
383 384 }
384 385
385 386
386 387 void QValueAxisPrivate::initializeDomain(AbstractDomain *domain)
387 388 {
388 389 if (orientation() == Qt::Vertical) {
389 390 if(!qFuzzyIsNull(m_max - m_min)) {
390 391 domain->setRangeY(m_min, m_max);
391 392 }
392 393 else {
393 394 setRange(domain->minY(), domain->maxY());
394 395 }
395 396 }
396 397 if (orientation() == Qt::Horizontal) {
397 398 if(!qFuzzyIsNull(m_max - m_min)) {
398 399 domain->setRangeX(m_min, m_max);
399 400 }
400 401 else {
401 402 setRange(domain->minX(), domain->maxX());
402 403 }
403 404 }
404 405 }
405 406
406 407 #include "moc_qvalueaxis.cpp"
407 408 #include "moc_qvalueaxis_p.cpp"
408 409
409 410 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,83 +1,84
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #ifndef QVALUEAXIS_H
22 22 #define QVALUEAXIS_H
23 23
24 24 #include "qabstractaxis.h"
25 25
26 26 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 class QValueAxisPrivate;
29 29
30 30 class QTCOMMERCIALCHART_EXPORT QValueAxis : public QAbstractAxis
31 31 {
32 32 Q_OBJECT
33 33 Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount NOTIFY tickCountChanged)
34 34 Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled)
35 35 Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
36 36 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
37 Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat)
37 Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat NOTIFY labelFormatChanged)
38 38
39 39 public:
40 40 explicit QValueAxis(QObject *parent = 0);
41 41 ~QValueAxis();
42 42
43 43 protected:
44 44 QValueAxis(QValueAxisPrivate &d, QObject *parent = 0);
45 45
46 46 public:
47 47 AxisType type() const;
48 48
49 49 //range handling
50 50 void setMin(qreal min);
51 51 qreal min() const;
52 52 void setMax(qreal max);
53 53 qreal max() const;
54 54 void setRange(qreal min, qreal max);
55 55
56 56 //ticks handling
57 57 void setTickCount(int count);
58 58 int tickCount() const;
59 59
60 60 void setLabelFormat(const QString &format);
61 61 QString labelFormat() const;
62 62
63 63 //TODO: depreciated !
64 64 void setNiceNumbersEnabled(bool enable = true);
65 65 bool niceNumbersEnabled() const;
66 66
67 67 public Q_SLOTS:
68 68 void applyNiceNumbers();
69 69
70 70 Q_SIGNALS:
71 71 void minChanged(qreal min);
72 72 void maxChanged(qreal max);
73 73 void rangeChanged(qreal min, qreal max);
74 74 void tickCountChanged(int tickCount);
75 void labelFormatChanged(const QString &format);
75 76
76 77 private:
77 78 Q_DECLARE_PRIVATE(QValueAxis)
78 79 Q_DISABLE_COPY(QValueAxis)
79 80 };
80 81
81 82 QTCOMMERCIALCHART_END_NAMESPACE
82 83
83 84 #endif // QVALUEAXIS_H
General Comments 0
You need to be logged in to leave comments. Login now