HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1662:1cbf106b76f3

category axis initialization

sauimone -

r1662:1cbf106b76f3

parent child

Context file:

r1662:1cbf106b76f3

Collapse all files

src/axis/qbarcategoriesaxis.cpp +51 -20

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarcategoriesaxis.h"
             #include "qbarcategoriesaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarCategoriesAxis
                 \brief The QBarCategoriesAxis class is used for manipulating chart's axis.
                 \mainclass
                 BarCategoriesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 See the \l {Line and BarChart Example} {Line and BarChart Example} to learn how to do that.
             */
             /*!
                 \qmlclass BarCategoriesAxis QBarCategoriesAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 To access BarCategoriesAxis you can use ChartView API. For example:
                 \code
                     ChartView {
                         BarCategoriesAxis {
                             id: categoryAxis
                             categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList BarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QBarCategoriesAxis::categoriesChanged()
               Axis emits signal when the categories of the axis has changed.
             */
             /*!
               \fn void QBarCategoriesAxis::minChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal BarCategoriesAxis::onMinChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QBarCategoriesAxis::maxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal BarCategoriesAxis::onMaxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QBarCategoriesAxis::rangeChanged(const QString &min, const QString &max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
                 QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QBarCategoriesAxis::~QBarCategoriesAxis()
             {
             }
             /*!
                 \internal
             */
             QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QBarCategoriesAxis::append(const QStringList &categories)
             {
                 if(categories.isEmpty()) return;
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
-                	d->m_categories.append(categories);
+                    d->m_categories.append(categories);
-                	setRange(categories.first(),categories.last());
+                    setRange(categories.first(),categories.last());
                 }else{
-                	d->m_categories.append(categories);
+                    d->m_categories.append(categories);
                 }
                 emit d->updated();
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QBarCategoriesAxis::append(const QString &category)
             {
-            	Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
-            	if (d->m_categories.isEmpty()) {
+                if (d->m_categories.isEmpty()) {
-            		d->m_categories.append(category);
+                    d->m_categories.append(category);
-            		setRange(category,category);
+                    setRange(category,category);
-            	}else{
+                }else{
-            		d->m_categories.append(category);
+                    d->m_categories.append(category);
+                }
-            	emit d->updated();
+                emit d->updated();
-            	emit categoriesChanged();
+                emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QBarCategoriesAxis::remove(const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     setRange(d->m_categories.first(),d->m_categories.last());
                     emit d->updated();
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QBarCategoriesAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
-                	d->m_categories.insert(index,category);
+                    d->m_categories.insert(index,category);
-                	setRange(category,category);
+                    setRange(category,category);
                 }else{
                     d->m_categories.insert(index,category);
                 }
                 emit d->updated();
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
             void QBarCategoriesAxis::clear()
             {
                 Q_D(QBarCategoriesAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit d->updated();
                 emit categoriesChanged();
             }
             void QBarCategoriesAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoriesAxis);
                 if(d->m_categories!=categories){
                 d->m_categories = categories;
                 setRange(categories.first(),categories.last());
                 emit d->updated();
                 emit categoriesChanged();
                 }
             }
             QStringList QBarCategoriesAxis::categories()
             {
                 Q_D(QBarCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QBarCategoriesAxis::count() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QBarCategoriesAxis::at(int index) const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
             void QBarCategoriesAxis::setMin(const QString& min)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QBarCategoriesAxis::min() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
             void QBarCategoriesAxis::setMax(const QString& max)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
             QString QBarCategoriesAxis::max() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
                 Q_D(QBarCategoriesAxis);
                 int minIndex = d->m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = d->m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 if (maxIndex <= minIndex) {
                     // max must be greater than min
                     return;
                 }
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - (minIndex))||d->m_minCategory!=minCategory) {
-                	d->m_minCategory = minCategory;
+                    d->m_minCategory = minCategory;
                     d->m_min = minIndex;
                     emit minChanged(minCategory);
                     changed = true;
                 }
                 if (!qFuzzyIsNull(d->m_max - (maxIndex))||d->m_maxCategory!=maxCategory ) {
                     d->m_max = maxIndex;
                     d->m_maxCategory = maxCategory;
                     emit maxChanged(maxCategory);
                     changed = true;
                 }
                 if (changed) {
                     d->emitRange();
                 }
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QBarCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
             QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
             {
             }
             void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
             void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
             void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QBarCategoriesAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
             int QBarCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QBarCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
+                Q_Q(QBarCategoriesAxis);
+                Q_UNUSED(count);
                 m_min = min;
                 m_max = max;
-                m_ticksCount = count;
+                int minIndex = qFloor(min);
-                //TODO:
+                int maxIndex = qFloor(max);
+                if (minIndex < 0) {
+                    minIndex = 0;
+                }
+                if (maxIndex > m_categories.count()-1){
+                    maxIndex = m_categories.count()-1;
+                }
+                bool changed = false;
+                if (m_minCategory != m_categories.at(minIndex)) {
+                    m_minCategory = m_categories.at(minIndex);
+                    emit q->minChanged(m_minCategory);
+                    changed = true;
+                }
+                if (m_maxCategory != m_categories.at(maxIndex)) {
+                    m_maxCategory = m_categories.at(maxIndex);
+                    emit q->maxChanged(m_maxCategory);
+                    changed = true;
+                }
+                if (changed) {
+                    emit q->rangeChanged(m_minCategory, m_maxCategory);
+                }
             }
             ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             void QBarCategoriesAxisPrivate::emitRange()
             {
-            	emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false);
+                emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false);
             }
             void QBarCategoriesAxisPrivate::initialize(Domain* domain)
             {
-                Q_UNUSED(domain);
+                if (qFuzzyCompare(m_max, m_min)) {
-                //TODO:
+                    if(m_orientation==Qt::Vertical){
+                        handleAxisRangeChanged(domain->minY(),domain->maxY(),domain->tickXCount());
+                    }else{
+                        handleAxisRangeChanged(domain->minX(),domain->maxX(),domain->tickYCount());
+                    }
+                }
             }
             #include "moc_qbarcategoriesaxis.cpp"
             #include "moc_qbarcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qvaluesaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "chartvaluesaxisx_p.h"
             #include "chartvaluesaxisy_p.h"
             #include "domain_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValuesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
             */
             /*!
                 \qmlclass ValuesAxis QValuesAxis
                 \brief The ValuesAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValuesAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(real min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(real max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool ValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                 	d->emitRange();
                     emit rangeChanged(d->m_min,d->m_max);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
             void QValuesAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValuesAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValuesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValuesAxisY(q,presenter);
                 }else{
                     return new ChartValuesAxisX(q,presenter);
                 }
             }
             void QValuesAxisPrivate::emitRange()
             {
             	emit changed(m_min, m_max, m_ticksCount, m_niceNumbers);
             }
             void QValuesAxisPrivate::initialize(Domain* domain)
             {
-                if(m_max==m_min){
+                if(qFuzzyCompare(m_max,m_min)) {
                     if(m_orientation==Qt::Vertical){
                         handleAxisRangeChanged(domain->minY(),domain->maxY(),domain->tickXCount());
                     }else{
                         handleAxisRangeChanged(domain->minX(),domain->maxX(),domain->tickYCount());
                     }
                 }
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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