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

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

LogDomain zoomout fix
Marek Rosa -
r2294:08fe4e70fe7a
parent child
Show More
Side by Side Unified
Context file:
r2294:08fe4e70fe7a Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,225 +1,225
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 qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
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 163 if(logAxis && logAxis->orientation()==Qt::Vertical)
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
165 165
166 166 if(logAxis && logAxis->orientation()==Qt::Horizontal)
167 167 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
168 168
169 169 return true;
170 170 }
171 171
172 172 bool LogXLogYDomain::detachAxis(QAbstractAxis* axis)
173 173 {
174 174 AbstractDomain::detachAxis(axis);
175 175 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
176 176
177 177 if(logAxis && logAxis->orientation()==Qt::Vertical)
178 178 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
179 179
180 180 if(logAxis && logAxis->orientation()==Qt::Horizontal)
181 181 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
182 182
183 183 return true;
184 184 }
185 185
186 186 void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
187 187 {
188 188 m_logBaseY = baseY;
189 189 m_logMinY = log10(m_minY) / log10(m_logBaseY);
190 190 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
191 191 }
192 192
193 193 void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
194 194 {
195 195 m_logBaseX = baseX;
196 196 m_logMinX = log10(m_minX) / log10(m_logBaseX);
197 197 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
198 198 }
199 199
200 200 // operators
201 201
202 202 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
203 203 {
204 204 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
205 205 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
206 206 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
207 207 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
208 208 }
209 209
210 210
211 211 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
212 212 {
213 213 return !(domain1 == domain2);
214 214 }
215 215
216 216
217 217 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
218 218 {
219 219 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
220 220 return dbg.maybeSpace();
221 221 }
222 222
223 223 #include "moc_logxlogydomain_p.cpp"
224 224
225 225 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,211 +1,211
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 qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
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 163 if(logAxis && logAxis->orientation()==Qt::Vertical)
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
165 165
166 166 return AbstractDomain::attachAxis(axis);
167 167 }
168 168
169 169 bool XLogYDomain::detachAxis(QAbstractAxis* axis)
170 170 {
171 171 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
172 172
173 173 if(logAxis && logAxis->orientation()==Qt::Vertical)
174 174 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
175 175
176 176 return AbstractDomain::detachAxis(axis);
177 177 }
178 178
179 179 void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
180 180 {
181 181 m_logBaseY = baseY;
182 182 m_logMinY = log10(m_minY) / log10(m_logBaseY);
183 183 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
184 184 }
185 185
186 186 // operators
187 187
188 188 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
189 189 {
190 190 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
191 191 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
192 192 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
193 193 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
194 194 }
195 195
196 196
197 197 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2)
198 198 {
199 199 return !(domain1 == domain2);
200 200 }
201 201
202 202
203 203 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
204 204 {
205 205 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
206 206 return dbg.maybeSpace();
207 207 }
208 208
209 209 #include "moc_xlogydomain_p.cpp"
210 210
211 211 QTCOMMERCIALCHART_END_NAMESPACE
General Comments 0
You need to be logged in to leave comments. Login now