HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1566:6a772a66a522

refactoring axises

sauimone -

r1566:6a772a66a522

parent child

Context file:

r1566:6a772a66a522

Collapse all files

src/axis/qabstractaxis.cpp +7 -4

             }
-            void QAbstractAxis::setMin(const QVariant& min)
+            void QAbstractAxis::setMin(const qreal min)
             {
                 d_ptr->setMin(min);
             }
-            void QAbstractAxis::setMax(const QVariant& max)
+            void QAbstractAxis::setMax(const qreal max)
             {
                 d_ptr->setMax(max);
             }
-            void QAbstractAxis::setRange(const QVariant& min, const QVariant& max)
+            void QAbstractAxis::setRange(const qreal min, const qreal max)
             {
                 d_ptr->setRange(min,max);
             }
                 m_shadesVisible(false),
                 m_shadesBrush(Qt::SolidPattern),
                 m_shadesOpacity(1.0),
-                m_orientation(Qt::Orientation(0))
+                m_orientation(Qt::Orientation(0)),
+                m_min(0),
+                m_max(0),
+                m_ticksCount(5)
             {
             }

src/axis/qabstractaxis.h +3 -3

                 QColor shadesBorderColor() const;
                 //range handling
-                void setMin(const QVariant& min);
+                void setMin(const qreal min);
-                void setMax(const QVariant& max);
+                void setMax(const qreal max);
-                void setRange(const QVariant& min, const QVariant& max);
+                void setRange(const qreal min, const qreal max);
                 void show();
                 void hide();

src/axis/qabstractaxis_p.h +8 -3

                 virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0;
             protected:
-                virtual void setMin(const QVariant& min) = 0;
+                virtual void setMin(const qreal min) = 0;
-                virtual void setMax(const QVariant& max) = 0;
+                virtual void setMax(const qreal max) = 0;
-                virtual void setRange(const QVariant& min, const QVariant& max) = 0;
+                virtual void setRange(const qreal min, const qreal max) = 0;
                 virtual int ticksCount() const = 0;
             public:
                 Qt::Orientation m_orientation;
+                // range
+                qreal m_min;
+                qreal m_max;
+                int m_ticksCount;
                 friend class QAbstractAxis;
             };

src/axis/qcategoriesaxis.cpp +71 -23

@@ -130,11 +130,7 QString QCategoriesAxis::at(int index) const
130	void QCategoriesAxis::setMin(const QString& minCategory)	130	void QCategoriesAxis::setMin(const QString& minCategory)
131	{	131	{
132	Q_D(QCategoriesAxis);	132	Q_D(QCategoriesAxis);
133	int minIndex = d->m_categories.indexOf(minCategory);	133	d->setMinCategory(minCategory);
134	if (minIndex == -1)
135	return;
136	// else
137	// QAbstractAxis::setMin(minIndex);
138	}	134	}
139		135
140	/*!	136	/*!
@@ -143,11 +139,7 void QCategoriesAxis::setMin(const QString& minCategory)
143	void QCategoriesAxis::setMax(const QString& maxCategory)	139	void QCategoriesAxis::setMax(const QString& maxCategory)
144	{	140	{
145	Q_D(QCategoriesAxis);	141	Q_D(QCategoriesAxis);
146	int maxIndex = d->m_categories.indexOf(maxCategory);	142	d->setMaxCategory(maxCategory);
147	if (maxIndex == -1)
148	return;
149	// else
150	// QAbstractAxis::setMax(maxIndex);
151	}	143	}
152		144
153	/*!	145	/*!
@@ -155,9 +147,8 void QCategoriesAxis::setMax(const QString& maxCategory)
155	*/	147	*/
156	void QCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)	148	void QCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
157	{	149	{
158	// TODO: what if maxCategory < minCategory?	150	Q_D(QCategoriesAxis);
159	~~setMin~~(minCategory);	151	d->setRangeCategory(minCategory,maxCategory);
160	setMax(maxCategory);
161	}	152	}
162		153
163	/*!	154	/*!
@@ -181,23 +172,68 QCategoriesAxisPrivate::~QCategoriesAxisPrivate()
181		172
182	}	173	}
183		174
		175	void QCategoriesAxisPrivate::setMinCategory(const QString& minCategory)
		176	{
		177	// Convert the category to value
		178	int minIndex = m_categories.indexOf(minCategory);
		179	if (minIndex == -1) {
		180	return;
		181	}
		182	setRange(minIndex,m_max);
		183	}
184		184
185	void QCategoriesAxisPrivate::setMin(const Q~~Variant~~& min)	185	void QCategoriesAxisPrivate::setMaxCategory(const QString& maxCategory)
186	{	186	{
187	Q_Q(QCategoriesAxis);	187	// Convert the category to value
188	q->setMin(min.toString());	188	int maxIndex = m_categories.indexOf(maxCategory);
		189	if (maxIndex == -1) {
		190	return;
		191	}
		192	setRange(m_min,maxIndex);
189	}	193	}
190		194
191	void QCategoriesAxisPrivate::set~~Max~~(const Q~~Variant~~& max)	195	void QCategoriesAxisPrivate::setRangeCategory(const QString& minCategory, const QString& maxCategory)
192	{	196	{
193	Q_Q(QCategoriesAxis);	197	// TODO:
194	q->setMax(max.toString());	198	int minIndex = m_categories.indexOf(minCategory);
		199	if (minIndex == -1) {
		200	return;
		201	}
		202	int maxIndex = m_categories.indexOf(maxCategory);
		203	if (maxIndex == -1) {
		204	return;
		205	}
		206	setRange(minIndex,maxIndex);
195	}	207	}
196		208
197	void QCategoriesAxisPrivate::set~~Range~~(const ~~QVariant~~& min, ~~const~~ ~~QVariant~~& ~~max~~)	209	void QCategoriesAxisPrivate::setMin(const qreal min)
198	{	210	{
199	Q_Q(QCategoriesAxis);	211	setRange(min,m_max);
200	q->setRange(min.toString(),max.toString());	212	}
		213
		214	void QCategoriesAxisPrivate::setMax(const qreal max)
		215	{
		216	setRange(m_min,max);
		217	}
		218
		219	void QCategoriesAxisPrivate::setRange(const qreal min, const qreal max)
		220	{
		221	Q_Q(QCategoriesAxis);
		222	bool changed = false;
		223	if (!qFuzzyIsNull(m_min - min)) {
		224	m_min = min;
		225	changed = true;
		226	}
		227
		228	if (!qFuzzyIsNull(m_max - max)) {
		229	m_max = max;
		230	changed = true;
		231	}
		232
		233	if (changed) {
		234	emit this->changed(m_min, m_max, m_ticksCount, false);
		235	emit q->categoriesChanged();
		236	}
201	}	237	}
202		238
203	int QCategoriesAxisPrivate::ticksCount() const	239	int QCategoriesAxisPrivate::ticksCount() const
@@ -205,6 +241,19 int QCategoriesAxisPrivate::ticksCount() const
205	return m_categories.count()+1;	241	return m_categories.count()+1;
206	}	242	}
207		243
		244	void QCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
		245	{
		246	// Q_Q(QCategoriesAxis);
		247	// q->setRange(min,max);
		248	// q->setTicksCount(count);
		249	m_min = min;
		250	m_max = max;
		251	m_ticksCount = count;
		252
		253	// TODO?:
		254	//emit updated();
		255	}
		256
208	ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)	257	ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
209	{	258	{
210	Q_Q( QCategoriesAxis);	259	Q_Q( QCategoriesAxis);
@@ -213,7 +262,6 ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
213	}else{	262	}else{
214	return new ChartCategoriesAxisX(q,presenter);	263	return new ChartCategoriesAxisX(q,presenter);
215	}	264	}
216
217	}	265	}
218		266
219	#include "moc_qcategoriesaxis.cpp"	267	#include "moc_qcategoriesaxis.cpp"

src/axis/qcategoriesaxis_p.h +15 -5

                 ChartAxis* createGraphics(ChartPresenter* presenter);
             private:
+                void setMinCategory(const QString& minCategory);
+                void setMaxCategory(const QString& maxCategory);
+                void setRangeCategory(const QString& minCategory, const QString& maxCategory);
                 //range handling
-                void setMin(const QVariant& min);
+                void setMin(const qreal min);
-                void setMax(const QVariant& max);
+                void setMax(const qreal max);
-                void setRange(const QVariant& min, const QVariant& max);
+                void setRange(const qreal min, const qreal max);
                 int ticksCount() const;
+            Q_SIGNALS:
+                void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
+            public Q_SLOTS:
+                void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 QStringList m_categories;
                 QString m_minCategory;
                 QString m_maxCategory;
-            Q_SIGNALS:
+            //    qreal m_rangeMin;
-                void updated();
+            //    qreal m_rangeMax;
             private:
                 Q_DECLARE_PUBLIC(QCategoriesAxis)

src/axis/qvaluesaxis.cpp +24 -37

@@ -131,23 +131,7 qreal QValuesAxis::max() const
131	void QValuesAxis::setRange(qreal min, qreal max)	131	void QValuesAxis::setRange(qreal min, qreal max)
132	{	132	{
133	Q_D(QValuesAxis);	133	Q_D(QValuesAxis);
134	bool changed = false;	134	d->setRange(min,max);
135	if (!qFuzzyIsNull(d->m_min - min)) {
136	d->m_min = min;
137	changed = true;
138	emit minChanged(min);
139	}
140
141	if (!qFuzzyIsNull(d->m_max - max)) {
142	d->m_max = max;
143	changed = true;
144	emit maxChanged(max);
145	}
146
147	if (changed) {
148	emit rangeChanged(d->m_min,d->m_max);
149	emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
150	}
151	}	135	}
152		136
153	/*!	137	/*!
@@ -196,10 +180,7 QAbstractAxis::AxisType QValuesAxis::type() const
196		180
197	QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):	181	QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
198	QAbstractAxisPrivate(q),	182	QAbstractAxisPrivate(q),
199	m_min(0),	183	m_niceNumbers(false)
200	m_max(0),
201	m_niceNumbers(false),
202	m_ticksCount(5)
203	{	184	{
204		185
205	}	186	}
@@ -217,30 +198,36 void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
217	}	198	}
218		199
219		200
220	void QValuesAxisPrivate::setMin(const ~~QVariant~~& min)	201	void QValuesAxisPrivate::setMin(const qreal min)
221	{	202	{
222	Q_Q(QValuesAxis);	203	setRange(min,m_max);
223	bool ok;
224	qreal value = min.toReal(&ok);
225	if(ok) q->setMin(value);
226	}	204	}
227		205
228	void QValuesAxisPrivate::setMax(const ~~QVariant~~& max)	206	void QValuesAxisPrivate::setMax(const qreal max)
229	{	207	{
230	Q_Q(QValuesAxis);	208	setRange(m_min,max);
231	bool ok;
232	qreal value = max.toReal(&ok);
233	if(ok) q->setMax(value);
234	}	209	}
235		210
236	void QValuesAxisPrivate::setRange(const ~~QVariant~~& min, const ~~QVariant~~& max)	211	void QValuesAxisPrivate::setRange(const qreal min, const qreal max)
237	{	212	{
238	Q_Q(QValuesAxis);	213	Q_Q(QValuesAxis);
239	bool ok1;	214	bool changed = false;
240	bool ok2;	215	if (!qFuzzyIsNull(m_min - min)) {
241	qreal value1 = min.toReal(&ok1);	216	m_min = min;
242	qreal value2 = max.toReal(&ok2);	217	changed = true;
243	if(ok1&&ok2) q->setRange(value1,value2);	218	emit q->minChanged(min);
		219	}
		220
		221	if (!qFuzzyIsNull(m_max - max)) {
		222	m_max = max;
		223	changed = true;
		224	emit q->maxChanged(max);
		225	}
		226
		227	if (changed) {
		228	emit q->rangeChanged(m_min,m_max);
		229	emit this->changed(m_min, m_max, m_ticksCount, m_niceNumbers);
		230	}
244	}	231	}
245		232
246	int QValuesAxisPrivate::ticksCount() const	233	int QValuesAxisPrivate::ticksCount() const

src/axis/qvaluesaxis_p.h +3 -6

                 ChartAxis* createGraphics(ChartPresenter* presenter);
             protected:
-                void setMin(const QVariant& min);
+                void setMin(const qreal min);
-                void setMax(const QVariant& max);
+                void setMax(const qreal max);
-                void setRange(const QVariant& min, const QVariant& max);
+                void setRange(const qreal min, const qreal max);
                 int ticksCount() const;
             private:
-                qreal m_min;
-                qreal m_max;
                 bool m_niceNumbers;
-                int m_ticksCount;
                 Q_DECLARE_PUBLIC(QValuesAxis)
             };

src/barchart/qbarseries.cpp +2 -1

             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
+            #include "qcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QAbstractAxis* QBarSeriesPrivate::createAxisX(QObject* parent)
             {
-                return new QValuesAxis(parent);
+                return new QCategoriesAxis(parent);
             }
             QAbstractAxis* QBarSeriesPrivate::createAxisY(QObject* parent)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages