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

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

Fix to domain initialization when log base was preset on axis before adding it to chart
Marek Rosa -
r2295:8468c10170a2
parent child
Show More
Side by Side Unified
Context file:
r2295:8468c10170a2 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,225 +1,229
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 "logxlogydomain_p.h"
22 22 #include "qabstractaxis_p.h"
23 23 #include "qlogvalueaxis.h"
24 24 #include <qmath.h>
25 25
26 26 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 LogXLogYDomain::LogXLogYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 30 m_logMinX(0),
31 31 m_logMaxX(1),
32 32 m_logBaseX(10),
33 33 m_logMinY(0),
34 34 m_logMaxY(1),
35 35 m_logBaseY(10)
36 36 {
37 37 }
38 38
39 39 LogXLogYDomain::~LogXLogYDomain()
40 40 {
41 41 }
42 42
43 43 void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
44 44 {
45 45 bool axisXChanged = false;
46 46 bool axisYChanged = false;
47 47
48 48 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
49 49 m_minX = minX;
50 50 m_maxX = maxX;
51 51 axisXChanged = true;
52 52 m_logMinX = log10(m_minX) / log10(m_logBaseX);
53 53 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
54 54 if(!m_signalsBlocked)
55 55 emit rangeHorizontalChanged(m_minX, m_maxX);
56 56 }
57 57
58 58 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
59 59 m_minY = minY;
60 60 m_maxY = maxY;
61 61 axisYChanged = true;
62 62 m_logMinY = log10(m_minY) / log10(m_logBaseY);
63 63 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
64 64 if(!m_signalsBlocked)
65 65 emit rangeVerticalChanged(m_minY, m_maxY);
66 66 }
67 67
68 68 if (axisXChanged || axisYChanged)
69 69 emit updated();
70 70 }
71 71
72 72 void LogXLogYDomain::zoomIn(const QRectF &rect)
73 73 {
74 74 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
75 75 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
76 76 qreal minX = qPow(m_logBaseX, newLogMinX);
77 77 qreal maxX = qPow(m_logBaseX, newLogMaxX);
78 78
79 79 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
80 80 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
81 81 qreal minY = qPow(m_logBaseY, newLogMinY);
82 82 qreal maxY = qPow(m_logBaseY, newLogMaxY);
83 83
84 84 setRange(minX, maxX, minY, maxY);
85 85 }
86 86
87 87 void LogXLogYDomain::zoomOut(const QRectF &rect)
88 88 {
89 89 qreal ratioX = m_size.width()/rect.width();
90 90 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
91 91 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
92 92 qreal minX = qPow(m_logBaseX, newLogMinX);
93 93 qreal maxX = qPow(m_logBaseX, newLogMaxX);
94 94
95 95 qreal ratioY = m_size.height()/rect.height();
96 96 qreal newLogMinY = m_logMinY - (m_logMaxY - m_logMinY) / ratioY;
97 97 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
98 98 qreal minY = qPow(m_logBaseY, newLogMinY);
99 99 qreal maxY = qPow(m_logBaseY, newLogMaxY);
100 100
101 101 setRange(minX, maxX, minY, maxY);
102 102 }
103 103
104 104 void LogXLogYDomain::move(qreal dx, qreal dy)
105 105 {
106 106 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
107 107 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
108 108 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
109 109
110 110 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
111 111 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
112 112 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
113 113
114 114 setRange(minX, maxX, minY, maxY);
115 115 }
116 116
117 117 QPointF LogXLogYDomain::calculateGeometryPoint(const QPointF &point) const
118 118 {
119 119 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
120 120 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
121 121 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
122 122 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
123 123 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
124 124 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
125 125 return QPointF(x, y);
126 126 }
127 127
128 128 QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
129 129 {
130 130 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
131 131 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
132 132 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
133 133 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
134 134
135 135 QVector<QPointF> result;
136 136 result.resize(vector.count());
137 137
138 138 for (int i = 0; i < vector.count(); ++i) {
139 139 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
140 140 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
141 141 result[i].setX(x);
142 142 result[i].setY(y);
143 143 }
144 144 return result;
145 145 }
146 146
147 147 QPointF LogXLogYDomain::calculateDomainPoint(const QPointF &point) const
148 148 {
149 149 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
150 150 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
151 151 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
152 152 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
153 153 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
154 154 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
155 155 return QPointF(x, y);
156 156 }
157 157
158 158 bool LogXLogYDomain::attachAxis(QAbstractAxis* axis)
159 159 {
160 160 AbstractDomain::attachAxis(axis);
161 161 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
162 162
163 if(logAxis && logAxis->orientation()==Qt::Vertical)
163 if(logAxis && logAxis->orientation()==Qt::Vertical) {
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
165 handleVerticalAxisBaseChanged(logAxis->base());
166 }
165 167
166 if(logAxis && logAxis->orientation()==Qt::Horizontal)
168 if(logAxis && logAxis->orientation()==Qt::Horizontal) {
167 169 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
170 handleHorizontalAxisBaseChanged(logAxis->base());
171 }
168 172
169 173 return true;
170 174 }
171 175
172 176 bool LogXLogYDomain::detachAxis(QAbstractAxis* axis)
173 177 {
174 178 AbstractDomain::detachAxis(axis);
175 179 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
176 180
177 181 if(logAxis && logAxis->orientation()==Qt::Vertical)
178 182 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
179 183
180 184 if(logAxis && logAxis->orientation()==Qt::Horizontal)
181 185 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
182 186
183 187 return true;
184 188 }
185 189
186 190 void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
187 191 {
188 192 m_logBaseY = baseY;
189 193 m_logMinY = log10(m_minY) / log10(m_logBaseY);
190 194 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
191 195 }
192 196
193 197 void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
194 198 {
195 199 m_logBaseX = baseX;
196 200 m_logMinX = log10(m_minX) / log10(m_logBaseX);
197 201 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
198 202 }
199 203
200 204 // operators
201 205
202 206 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
203 207 {
204 208 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
205 209 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
206 210 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
207 211 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
208 212 }
209 213
210 214
211 215 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
212 216 {
213 217 return !(domain1 == domain2);
214 218 }
215 219
216 220
217 221 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
218 222 {
219 223 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
220 224 return dbg.maybeSpace();
221 225 }
222 226
223 227 #include "moc_logxlogydomain_p.cpp"
224 228
225 229 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,212 +1,214
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 "logxydomain_p.h"
22 22 #include "qabstractaxis_p.h"
23 23 #include "qlogvalueaxis.h"
24 24 #include <qmath.h>
25 25
26 26 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 LogXYDomain::LogXYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 30 m_logMinX(0),
31 31 m_logMaxX(1),
32 32 m_logBaseX(10)
33 33 {
34 34 }
35 35
36 36 LogXYDomain::~LogXYDomain()
37 37 {
38 38 }
39 39
40 40 void LogXYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
41 41 {
42 42 bool axisXChanged = false;
43 43 bool axisYChanged = false;
44 44
45 45 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
46 46 m_minX = minX;
47 47 m_maxX = maxX;
48 48 axisXChanged = true;
49 49 m_logMinX = log10(m_minX) / log10(m_logBaseX);
50 50 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
51 51 if(!m_signalsBlocked)
52 52 emit rangeHorizontalChanged(m_minX, m_maxX);
53 53 }
54 54
55 55 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
56 56 m_minY = minY;
57 57 m_maxY = maxY;
58 58 axisYChanged = true;
59 59 if(!m_signalsBlocked)
60 60 emit rangeVerticalChanged(m_minY, m_maxY);
61 61 }
62 62
63 63 if (axisXChanged || axisYChanged)
64 64 emit updated();
65 65 }
66 66
67 67 void LogXYDomain::zoomIn(const QRectF &rect)
68 68 {
69 69 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
70 70 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
71 71 qreal minX = qPow(m_logBaseX, newLogMinX);
72 72 qreal maxX = qPow(m_logBaseX, newLogMaxX);
73 73
74 74 qreal dy = spanY() / m_size.height();
75 75 qreal minY = m_minY;
76 76 qreal maxY = m_maxY;
77 77
78 78 minY = maxY - dy * rect.bottom();
79 79 maxY = maxY - dy * rect.top();
80 80
81 81 setRange(minX, maxX, minY, maxY);
82 82 }
83 83
84 84 void LogXYDomain::zoomOut(const QRectF &rect)
85 85 {
86 86 qreal ratioX = m_size.width()/rect.width();
87 87 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
88 88 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
89 89 qreal minX = qPow(m_logBaseX, newLogMinX);
90 90 qreal maxX = qPow(m_logBaseX, newLogMaxX);
91 91
92 92 qreal dy = spanY() / rect.height();
93 93 qreal minY = m_minY;
94 94 qreal maxY = m_maxY;
95 95
96 96 maxY = minY + dy * rect.bottom();
97 97 minY = maxY - dy * m_size.height();
98 98
99 99 setRange(minX, maxX, minY, maxY);
100 100 }
101 101
102 102 void LogXYDomain::move(qreal dx, qreal dy)
103 103 {
104 104 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
105 105 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
106 106 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
107 107
108 108 qreal y = spanY() / m_size.height();
109 109 qreal minY = m_minY;
110 110 qreal maxY = m_maxY;
111 111
112 112 if (dy != 0) {
113 113 minY = minY + y * dy;
114 114 maxY = maxY + y * dy;
115 115 }
116 116 setRange(minX, maxX, minY, maxY);
117 117 }
118 118
119 119 QPointF LogXYDomain::calculateGeometryPoint(const QPointF &point) const
120 120 {
121 121 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
122 122 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
123 123 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
124 124
125 125 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
126 126 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
127 127 return QPointF(x, y);
128 128 }
129 129
130 130 QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
131 131 {
132 132 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
133 133 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
134 134 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
135 135
136 136 QVector<QPointF> result;
137 137 result.resize(vector.count());
138 138
139 139 for (int i = 0; i < vector.count(); ++i) {
140 140 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
141 141 qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
142 142 result[i].setX(x);
143 143 result[i].setY(y);
144 144 }
145 145 return result;
146 146 }
147 147
148 148 QPointF LogXYDomain::calculateDomainPoint(const QPointF &point) const
149 149 {
150 150 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
151 151 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
152 152 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
153 153 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
154 154 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
155 155 return QPointF(x, y);
156 156 }
157 157
158 158 bool LogXYDomain::attachAxis(QAbstractAxis* axis)
159 159 {
160 160 AbstractDomain::attachAxis(axis);
161 161 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
162 162
163 if(logAxis && logAxis->orientation()==Qt::Horizontal)
163 if(logAxis && logAxis->orientation()==Qt::Horizontal) {
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
165 handleHorizontalAxisBaseChanged(logAxis->base());
166 }
165 167
166 168 return true;
167 169 }
168 170
169 171 bool LogXYDomain::detachAxis(QAbstractAxis* axis)
170 172 {
171 173 AbstractDomain::detachAxis(axis);
172 174 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
173 175
174 176 if(logAxis && logAxis->orientation()==Qt::Horizontal)
175 177 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
176 178
177 179 return true;
178 180 }
179 181
180 182 void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
181 183 {
182 184 m_logBaseX = baseX;
183 185 m_logMinX = log10(m_minX) / log10(m_logBaseX);
184 186 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
185 187 }
186 188
187 189 // operators
188 190
189 191 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2)
190 192 {
191 193 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
192 194 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
193 195 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
194 196 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
195 197 }
196 198
197 199
198 200 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXYDomain &domain1, const LogXYDomain &domain2)
199 201 {
200 202 return !(domain1 == domain2);
201 203 }
202 204
203 205
204 206 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain)
205 207 {
206 208 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
207 209 return dbg.maybeSpace();
208 210 }
209 211
210 212 #include "moc_logxydomain_p.cpp"
211 213
212 214 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,211 +1,212
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 "xlogydomain_p.h"
22 22 #include "qabstractaxis_p.h"
23 23 #include "qlogvalueaxis.h"
24 24 #include <qmath.h>
25 25
26 26 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 XLogYDomain::XLogYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 30 m_logMinY(0),
31 31 m_logMaxY(1),
32 32 m_logBaseY(10)
33 33 {
34 34 }
35 35
36 36 XLogYDomain::~XLogYDomain()
37 37 {
38 38 }
39 39
40 40 void XLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
41 41 {
42 42 bool axisXChanged = false;
43 43 bool axisYChanged = false;
44 44
45 45 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
46 46 m_minX = minX;
47 47 m_maxX = maxX;
48 48 axisXChanged = true;
49 49 if(!m_signalsBlocked)
50 50 emit rangeHorizontalChanged(m_minX, m_maxX);
51 51 }
52 52
53 53 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
54 54 m_minY = minY;
55 55 m_maxY = maxY;
56 56 axisYChanged = true;
57 57 m_logMinY = log10(m_minY) / log10(m_logBaseY);
58 58 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
59 59 if(!m_signalsBlocked)
60 60 emit rangeVerticalChanged(m_minY, m_maxY);
61 61 }
62 62
63 63 if (axisXChanged || axisYChanged)
64 64 emit updated();
65 65 }
66 66
67 67 void XLogYDomain::zoomIn(const QRectF &rect)
68 68 {
69 69 qreal dx = spanX() / m_size.width();
70 70 qreal maxX = m_maxX;
71 71 qreal minX = m_minX;
72 72
73 73 maxX = minX + dx * rect.right();
74 74 minX = minX + dx * rect.left();
75 75
76 76 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
77 77 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
78 78 qreal minY = qPow(m_logBaseY, newLogMinY);
79 79 qreal maxY = qPow(m_logBaseY, newLogMaxY);
80 80
81 81 setRange(minX, maxX, minY, maxY);
82 82 }
83 83
84 84 void XLogYDomain::zoomOut(const QRectF &rect)
85 85 {
86 86 qreal dx = spanX() / rect.width();
87 87 qreal maxX = m_maxX;
88 88 qreal minX = m_minX;
89 89
90 90 minX = maxX - dx * rect.right();
91 91 maxX = minX + dx * m_size.width();
92 92
93 93 qreal ratioY = m_size.height()/rect.height();
94 94 qreal newLogMinY = m_logMinY - (m_logMaxY - m_logMinY) / ratioY;
95 95 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
96 96 qreal minY = qPow(m_logBaseY, newLogMinY);
97 97 qreal maxY = qPow(m_logBaseY, newLogMaxY);
98 98
99 99 setRange(minX, maxX, minY, maxY);
100 100 }
101 101
102 102 void XLogYDomain::move(qreal dx, qreal dy)
103 103 {
104 104 qreal x = spanX() / m_size.width();
105 105 qreal maxX = m_maxX;
106 106 qreal minX = m_minX;
107 107
108 108 if (dx != 0) {
109 109 minX = minX + x * dx;
110 110 maxX = maxX + x * dx;
111 111 }
112 112
113 113 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
114 114 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
115 115 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
116 116
117 117 setRange(minX, maxX, minY, maxY);
118 118 }
119 119
120 120 QPointF XLogYDomain::calculateGeometryPoint(const QPointF &point) const
121 121 {
122 122 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
123 123 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
124 124 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
125 125
126 126 qreal x = (point.x() - m_minX) * deltaX;
127 127 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
128 128 return QPointF(x, y);
129 129 }
130 130
131 131 QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
132 132 {
133 133 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
134 134 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
135 135 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
136 136
137 137 QVector<QPointF> result;
138 138 result.resize(vector.count());
139 139
140 140 for (int i = 0; i < vector.count(); ++i) {
141 141 qreal x = (vector[i].x() - m_minX) * deltaX;
142 142 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
143 143 result[i].setX(x);
144 144 result[i].setY(y);
145 145 }
146 146 return result;
147 147 }
148 148
149 149 QPointF XLogYDomain::calculateDomainPoint(const QPointF &point) const
150 150 {
151 151 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
152 152 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
153 153 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
154 154 qreal x = point.x() / deltaX + m_minX;
155 155 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
156 156 return QPointF(x, y);
157 157 }
158 158
159 159 bool XLogYDomain::attachAxis(QAbstractAxis* axis)
160 160 {
161 161 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
162 162
163 if(logAxis && logAxis->orientation()==Qt::Vertical)
163 if(logAxis && logAxis->orientation()==Qt::Vertical){
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
165
165 handleVerticalAxisBaseChanged(logAxis->base());
166 }
166 167 return AbstractDomain::attachAxis(axis);
167 168 }
168 169
169 170 bool XLogYDomain::detachAxis(QAbstractAxis* axis)
170 171 {
171 172 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
172 173
173 174 if(logAxis && logAxis->orientation()==Qt::Vertical)
174 175 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
175 176
176 177 return AbstractDomain::detachAxis(axis);
177 178 }
178 179
179 180 void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
180 181 {
181 182 m_logBaseY = baseY;
182 183 m_logMinY = log10(m_minY) / log10(m_logBaseY);
183 184 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
184 185 }
185 186
186 187 // operators
187 188
188 189 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
189 190 {
190 191 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
191 192 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
192 193 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
193 194 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
194 195 }
195 196
196 197
197 198 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2)
198 199 {
199 200 return !(domain1 == domain2);
200 201 }
201 202
202 203
203 204 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
204 205 {
205 206 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
206 207 return dbg.maybeSpace();
207 208 }
208 209
209 210 #include "moc_xlogydomain_p.cpp"
210 211
211 212 QTCOMMERCIALCHART_END_NAMESPACE
General Comments 0
You need to be logged in to leave comments. Login now