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

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

Fixed: chart not redrawing when logaxis's logBase value changed
Marek Rosa -
r2322:2741539ef9e9
parent child
Show More
Side by Side Unified
Context file:
r2322:2741539ef9e9 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,123 +1,127
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 "chartlogvalueaxisx_p.h"
22 22 #include "chartpresenter_p.h"
23 23 #include "qlogvalueaxis.h"
24 24 #include "chartlayout_p.h"
25 25 #include <QGraphicsLayout>
26 26 #include <QFontMetrics>
27 27 #include <qmath.h>
28 28
29 29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 30
31 31 ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem* item)
32 32 : HorizontalAxis(axis, item),
33 33 m_axis(axis)
34 34 {
35 QObject::connect(m_axis,SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
35 36 }
36 37
37 38 ChartLogValueAxisX::~ChartLogValueAxisX()
38 39 {
39 40 }
40 41
41 42 QVector<qreal> ChartLogValueAxisX::calculateLayout() const
42 43 {
43 44 QVector<qreal> points;
44 45
45 46 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
46 47 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
47 48 qreal leftEdge = logMin < logMax ? logMin : logMax;
48 49 qreal ceilEdge = ceil(leftEdge);
49 50 int tickCount = qAbs(qRound(logMax - logMin));
50 51 tickCount++;
51 52
52 53 points.resize(tickCount);
53 54 const QRectF &gridRect = gridGeometry();
54 55 const qreal deltaX = gridRect.width() / qAbs(logMax - logMin);
55 56 for (int i = 0; i < tickCount; ++i)
56 57 points[i] = (ceilEdge + i) * deltaX - leftEdge * deltaX + gridRect.left();
57 58
58 59 return points;
59 60 }
60 61
61 62 void ChartLogValueAxisX::updateGeometry()
62 63 {
63 64 const QVector<qreal>& layout = ChartAxis::layout();
64 65 if (layout.isEmpty())
65 66 return;
66 67 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
67 68 HorizontalAxis::updateGeometry();
68 69 }
69 70
70 //void ChartLogValueAxisX::handleAxisUpdated()
71 //{
72 // ChartAxis::handleAxisUpdated();
73 //}
71 void ChartLogValueAxisX::handleBaseChanged(qreal base)
72 {
73 Q_UNUSED(base);
74 if(presenter()) presenter()->layout()->invalidate();
75 }
74 76
75 77 QSizeF ChartLogValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
76 78 {
77 79 Q_UNUSED(constraint)
78 80
79 81 QFontMetrics fn(font());
80 82 QSizeF sh;
81 83
82 84 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
83 85 QStringList ticksList;
84 86 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
85 87 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
86 88 int tickCount = qAbs(qRound(logMax - logMin));
87 89 tickCount++;
88 90
89 91 if (m_axis->max() > m_axis->min() && tickCount > 1)
90 92 ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
91 93 else
92 94 ticksList.append(QString(" "));
93 95 qreal width = 0;
94 96 qreal height = 0;
95 97
96 98
97 99 switch (which) {
98 100 case Qt::MinimumSize:{
99 101 int count = qMax(ticksList.last().count(),ticksList.first().count());
100 102 width = fn.averageCharWidth() * count;
101 103 height = fn.height() + labelPadding();
102 104 width = qMax(width,base.width());
103 105 height += base.height();
104 106 sh = QSizeF(width,height);
105 107 break;
106 108 }
107 109 case Qt::PreferredSize: {
108 110 int count = qMax(ticksList.last().count(),ticksList.first().count());
109 111 width=fn.averageCharWidth() * count;
110 112 height=fn.height()+labelPadding();
111 113 width=qMax(width,base.width());
112 114 height+=base.height();
113 115 sh = QSizeF(width,height);
114 116 break;
115 117 }
116 118 default:
117 119 break;
118 120 }
119 121
120 122 return sh;
121 123 }
122 124
125 #include "moc_chartlogvalueaxisx_p.cpp"
126
123 127 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,59 +1,64
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 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef CHARTLOGVALUEAXISX_H
31 31 #define CHARTLOGVALUEAXISX_H
32 32
33 33 #include "horizontalaxis_p.h"
34 34
35 35 QTCOMMERCIALCHART_BEGIN_NAMESPACE
36 36
37 37 class QLogValueAxis;
38 38 class ChartPresenter;
39 39
40 40 class ChartLogValueAxisX : public HorizontalAxis
41 41 {
42 Q_OBJECT
43
42 44 public:
43 45 ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem* item);
44 46 ~ChartLogValueAxisX();
45 47
46 48 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
47 49
48 50 protected:
49 51 void handleAxisUpdated();
50 52 QVector<qreal> calculateLayout() const;
51 53 void updateGeometry();
52 54
55 private Q_SLOTS:
56 void handleBaseChanged(qreal base);
57
53 58 private:
54 59 QLogValueAxis *m_axis;
55 60 };
56 61
57 62 QTCOMMERCIALCHART_END_NAMESPACE
58 63
59 64 #endif /* CHARTLOGVALUEAXISX_H */
Show file before | Show file after | Hide comments
@@ -1,120 +1,124
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 "chartlogvalueaxisy_p.h"
22 22 #include "chartpresenter_p.h"
23 23 #include "qlogvalueaxis.h"
24 24 #include "chartlayout_p.h"
25 25 #include <QGraphicsLayout>
26 26 #include <QFontMetrics>
27 27 #include <qmath.h>
28 28
29 29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 30
31 31 ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem* item)
32 32 : VerticalAxis(axis, item),
33 33 m_axis(axis)
34 34 {
35 QObject::connect(m_axis, SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
35 36 }
36 37
37 38 ChartLogValueAxisY::~ChartLogValueAxisY()
38 39 {
39 40 }
40 41
41 42 QVector<qreal> ChartLogValueAxisY::calculateLayout() const
42 43 {
43 44 QVector<qreal> points;
44 45 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
45 46 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
46 47 qreal leftEdge = logMin < logMax ? logMin : logMax;
47 48 qreal ceilEdge = ceil(leftEdge);
48 49 int tickCount = qAbs(qRound(logMax - logMin));
49 50 tickCount++;
50 51
51 52 points.resize(tickCount);
52 53 const QRectF &gridRect = gridGeometry();
53 54 const qreal deltaY = gridRect.height() / qAbs(logMax - logMin);
54 55 for (int i = 0; i < tickCount; ++i)
55 56 points[i] = (ceilEdge + i) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
56 57
57 58 return points;
58 59 }
59 60
60 61
61 62 void ChartLogValueAxisY::updateGeometry()
62 63 {
63 64 const QVector<qreal> &layout = ChartAxis::layout();
64 65 if (layout.isEmpty())
65 66 return;
66 67 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
67 68 VerticalAxis::updateGeometry();
68 69 }
69 70
70 //void ChartLogValueAxisY::handleAxisUpdated()
71 //{
72 // ChartAxis::handleAxisUpdated();
73 //}
71 void ChartLogValueAxisY::handleBaseChanged(qreal base)
72 {
73 Q_UNUSED(base);
74 if(presenter()) presenter()->layout()->invalidate();
75 }
74 76
75 77 QSizeF ChartLogValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
76 78 {
77 79 Q_UNUSED(constraint)
78 80
79 81 QFontMetrics fn(font());
80 82 QSizeF sh;
81 83
82 84 QSizeF base = VerticalAxis::sizeHint(which, constraint);
83 85 QStringList ticksList;
84 86 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
85 87 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
86 88 int tickCount = qAbs(qRound(logMax - logMin));
87 89 tickCount++;
88 90 if (m_axis->max() > m_axis->min() && tickCount > 1)
89 91 ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
90 92 else
91 93 ticksList.append(QString(" "));
92 94 qreal width = 0;
93 95 qreal height = 0;
94 96
95 97 switch (which) {
96 98 case Qt::MinimumSize: {
97 99 width = fn.boundingRect("...").width() + labelPadding();
98 100 width += base.width();
99 101 height = fn.height();
100 102 height = qMax(height,base.height());
101 103 sh = QSizeF(width,height);
102 104 break;
103 105 }
104 106 case Qt::PreferredSize: {
105 107 int count = qMax(ticksList.first().count() , ticksList.last().count());
106 108 width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
107 109 width += base.width();
108 110 height = fn.height() * ticksList.count();
109 111 height = qMax(height,base.height());
110 112 sh = QSizeF(width,height);
111 113 break;
112 114 }
113 115 default:
114 116 break;
115 117 }
116 118
117 119 return sh;
118 120 }
119 121
122 #include "moc_chartlogvalueaxisy_p.cpp"
123
120 124 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,59 +1,64
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 // W A R N I N G
22 22 // -------------
23 23 //
24 24 // This file is not part of the QtCommercial Chart API. It exists purely as an
25 25 // implementation detail. This header file may change from version to
26 26 // version without notice, or even be removed.
27 27 //
28 28 // We mean it.
29 29
30 30 #ifndef CHARTLOGVALUEAXISY_H
31 31 #define CHARTLOGVALUEAXISY_H
32 32
33 33 #include "verticalaxis_p.h"
34 34
35 35 QTCOMMERCIALCHART_BEGIN_NAMESPACE
36 36
37 37 class QLogValueAxis;
38 38 class ChartPresenter;
39 39
40 40 class ChartLogValueAxisY : public VerticalAxis
41 41 {
42 Q_OBJECT
43
42 44 public:
43 45 ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem* item);
44 46 ~ChartLogValueAxisY();
45 47
46 48 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
47 49
48 50 protected:
49 51 void handleAxisUpdated();
50 52 QVector<qreal> calculateLayout() const;
51 53 void updateGeometry();
52 54
55 private Q_SLOTS:
56 void handleBaseChanged(qreal base);
57
53 58 private:
54 59 QLogValueAxis *m_axis;
55 60 };
56 61
57 62 QTCOMMERCIALCHART_END_NAMESPACE
58 63
59 64 #endif /* CHARTLOGVALUEAXISY_H */
Show file before | Show file after | Hide comments
@@ -1,229 +1,231
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 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 167
168 168 if(logAxis && logAxis->orientation()==Qt::Horizontal) {
169 169 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
170 170 handleHorizontalAxisBaseChanged(logAxis->base());
171 171 }
172 172
173 173 return true;
174 174 }
175 175
176 176 bool LogXLogYDomain::detachAxis(QAbstractAxis* axis)
177 177 {
178 178 AbstractDomain::detachAxis(axis);
179 179 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
180 180
181 181 if(logAxis && logAxis->orientation()==Qt::Vertical)
182 182 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
183 183
184 184 if(logAxis && logAxis->orientation()==Qt::Horizontal)
185 185 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
186 186
187 187 return true;
188 188 }
189 189
190 190 void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
191 191 {
192 192 m_logBaseY = baseY;
193 193 m_logMinY = log10(m_minY) / log10(m_logBaseY);
194 194 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
195 emit updated();
195 196 }
196 197
197 198 void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
198 199 {
199 200 m_logBaseX = baseX;
200 201 m_logMinX = log10(m_minX) / log10(m_logBaseX);
201 202 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
203 emit updated();
202 204 }
203 205
204 206 // operators
205 207
206 208 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
207 209 {
208 210 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
209 211 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
210 212 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
211 213 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
212 214 }
213 215
214 216
215 217 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
216 218 {
217 219 return !(domain1 == domain2);
218 220 }
219 221
220 222
221 223 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
222 224 {
223 225 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
224 226 return dbg.maybeSpace();
225 227 }
226 228
227 229 #include "moc_logxlogydomain_p.cpp"
228 230
229 231 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,214 +1,215
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 163 if(logAxis && logAxis->orientation()==Qt::Horizontal) {
164 164 QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
165 165 handleHorizontalAxisBaseChanged(logAxis->base());
166 166 }
167 167
168 168 return true;
169 169 }
170 170
171 171 bool LogXYDomain::detachAxis(QAbstractAxis* axis)
172 172 {
173 173 AbstractDomain::detachAxis(axis);
174 174 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
175 175
176 176 if(logAxis && logAxis->orientation()==Qt::Horizontal)
177 177 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
178 178
179 179 return true;
180 180 }
181 181
182 182 void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
183 183 {
184 184 m_logBaseX = baseX;
185 185 m_logMinX = log10(m_minX) / log10(m_logBaseX);
186 186 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
187 emit updated();
187 188 }
188 189
189 190 // operators
190 191
191 192 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2)
192 193 {
193 194 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
194 195 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
195 196 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
196 197 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
197 198 }
198 199
199 200
200 201 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXYDomain &domain1, const LogXYDomain &domain2)
201 202 {
202 203 return !(domain1 == domain2);
203 204 }
204 205
205 206
206 207 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain)
207 208 {
208 209 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
209 210 return dbg.maybeSpace();
210 211 }
211 212
212 213 #include "moc_logxydomain_p.cpp"
213 214
214 215 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,212 +1,213
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 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 167 return AbstractDomain::attachAxis(axis);
168 168 }
169 169
170 170 bool XLogYDomain::detachAxis(QAbstractAxis* axis)
171 171 {
172 172 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
173 173
174 174 if(logAxis && logAxis->orientation()==Qt::Vertical)
175 175 QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
176 176
177 177 return AbstractDomain::detachAxis(axis);
178 178 }
179 179
180 180 void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
181 181 {
182 182 m_logBaseY = baseY;
183 183 m_logMinY = log10(m_minY) / log10(m_logBaseY);
184 184 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
185 emit updated();
185 186 }
186 187
187 188 // operators
188 189
189 190 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
190 191 {
191 192 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
192 193 qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
193 194 qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
194 195 qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
195 196 }
196 197
197 198
198 199 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2)
199 200 {
200 201 return !(domain1 == domain2);
201 202 }
202 203
203 204
204 205 QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
205 206 {
206 207 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
207 208 return dbg.maybeSpace();
208 209 }
209 210
210 211 #include "moc_xlogydomain_p.cpp"
211 212
212 213 QTCOMMERCIALCHART_END_NAMESPACE
General Comments 0
You need to be logged in to leave comments. Login now