HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1834:aeeb738d6b7d

Some axes docs update

Marek Rosa -

r1834:aeeb738d6b7d

parent child

Context file:

r1834:aeeb738d6b7d

Collapse all files

src/axis/categoryaxis/qcategoryaxis.cpp +25 -3

             /****************************************************************************
             **
             ** 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 "qcategoryaxis.h"
             #include "qcategoryaxis_p.h"
             #include "chartcategoryaxisx_p.h"
             #include "chartcategoryaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QCategoryAxis
-                \brief The QCategoryAxis class is used for manipulating chart's axis.
+                \brief The QCategoryAxis class allows putting a named ranges on the axis.
                 \mainclass
+                This class can be used when the underlying data needs to be given extra meaning.
+                Unlike with the QBarCategoryAxis the QCategoryAxis allows the categories ranges widths to be specified freely.
             */
             /*!
                 \qmlclass CategoryAxis QCategoryAxis
-                \brief The Axis element is used for manipulating chart's axes.
+                \brief The QCategoryAxis class allows putting a named ranges on the axis.
+            */
+            /*!
+              \property QCategoryAxis::startValue
+              Defines the low end of the first category on the axis.
+            */
+            /*!
+              \qmlproperty int CategoryAxis::startValue
+              Defines the low end of the first category on the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QCategoryAxis::QCategoryAxis(QObject *parent):
                 QValueAxis(*new QCategoryAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QCategoryAxis::~QCategoryAxis()
             {
                 //    Q_D(QValueAxis);
                 //    if(d->m_dataset) {
                 //        d->m_dataset->removeAxis(this);
                 //    }
             }
             /*!
                 \internal
             */
             QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
             {
             }
             /*!
                 Appends new category to the axis with an \a categoryLabel.
                 Category label has to be unique.
                 Parameter \a categoryHighEnd specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             void QCategoryAxis::append(const QString& categoryLabel, qreal categoryHighEnd)
             {
                 Q_D(QCategoryAxis);
                 if (!d->m_categories.contains(categoryLabel))
                 {
                     if(d->m_categories.isEmpty()){
                         Range range(d->m_categoryMinimum, categoryHighEnd);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
                     }else if (categoryHighEnd > categoryEnd(d->m_categories.last())){
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryHighEnd));
                         d->m_categories.append(categoryLabel);
                     }
                 }
             }
             /*!
-                Sets to \a min the low end limit of the first category on the axis.
+                Returns the low end limit of the first category on the axis.
+            */
+            qreal QCategoryAxis::startValue() const
+            {
+                Q_D(const QCategoryAxis);
+                return d->m_categoryMinimum;
+            }
+            /*!
+                Sets \a min to be the low end limit of the first category on the axis.
             */
             void QCategoryAxis::setStartValue(qreal min)
             {
                 Q_D(QCategoryAxis);
                 if(d->m_categories.isEmpty()){
                     d->m_categoryMinimum = min;
                 }else{
                     Range range = d->m_categoriesMap.value(d->m_categories.first());
                     d->m_categoriesMap.insert(d->m_categories.first(), Range(min, range.second));
                 }
             }
             /*!
                 Returns the low end limit of the category specified by an \a categoryLabel
             */
             qreal QCategoryAxis::categoryStart(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
             qreal QCategoryAxis::categoryEnd(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
             }
             /*!
                 Removes an interval specified by the \a categoryLabel from the axis
             */
             void QCategoryAxis::remove(const QString &categoryLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(categoryLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.removeAt(labelIndex);
                     d->m_categoriesMap.remove(categoryLabel);
                     // the range of the interval that follows (if exists) needs to be updated
                     if (labelIndex < d->m_categories.count()) {
                         QString label = d->m_categories.at(labelIndex);
                         Range range = d->m_categoriesMap.value(label);
                         // set the range
                         if (labelIndex == 0) {
                             range.first = d->m_categoryMinimum;
                             d->m_categoriesMap.insert(label, range);
                         } else {
                             range.first = d->m_categoriesMap.value(d->m_categories.at(labelIndex - 1)).second;
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
                     d->emitUpdated();
                 }
             }
             /*!
               Replaces \a oldLabel of an existing category with a \a newLabel
               If the old label does not exist the method returns without making any changes.
              */
             void QCategoryAxis::replaceLabel(const QString& oldLabel, const QString& newLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(oldLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.replace(labelIndex, newLabel);
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
                     d->emitUpdated();
                 }
             }
             /*!
               Returns the list of the intervals labels
              */
             QStringList QCategoryAxis::categoriesLabels()
             {
                 Q_D(QCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of intervals.
              */
             int QCategoryAxis::count() const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QCategoryAxis::type() const
             {
                 return QAbstractAxis::AxisTypeCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis* q):
                 QValueAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
             QCategoryAxisPrivate::~QCategoryAxisPrivate()
             {
             }
             int QCategoryAxisPrivate::ticksCount() const
             {
                 return m_categories.count() + 1;
             }
             void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 Q_UNUSED(count);
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 //m_min = min;
                 //m_max = max;
             }
             ChartAxis* QCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QCategoryAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoryAxisY(q,presenter);
                 }else{
                     return new ChartCategoryAxisX(q,presenter);
                 }
             }
             #include "moc_qcategoryaxis.cpp"
             #include "moc_qcategoryaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/qcategoryaxis.h +2 -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$
             **
             ****************************************************************************/
             #ifndef QCATEGORIESAXIS_H
             #define QCATEGORIESAXIS_H
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QCategoryAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QCategoryAxis : public QValueAxis
             {
                 Q_OBJECT
+                Q_PROPERTY(qreal startValue READ startValue WRITE setStartValue)
             public:
                 explicit QCategoryAxis(QObject *parent = 0);
                 ~QCategoryAxis();
             protected:
                 QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
                 void append(const QString& label, qreal categoryHighEnd);
                 void remove(const QString& label);
                 void replaceLabel(const QString& oldLabel, const QString& newLabel);
+                qreal startValue() const;
                 void setStartValue(qreal min);
                 qreal categoryStart(const QString& categoryLabel) const;
                 qreal categoryEnd(const QString& categoryLabel) const;
                 QStringList categoriesLabels();
                 int count() const;
             private:
                 Q_DECLARE_PRIVATE(QCategoryAxis)
                 Q_DISABLE_COPY(QCategoryAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_H

src/axis/categoryaxis/qcategoryaxis_p.h 0 -2

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QCATEGORYAXIS_P_H
             #define QCATEGORYAXIS_P_H
             #include "qcategoryaxis.h"
             #include "qvalueaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QPair<qreal, qreal> Range;
             class QCategoryAxisPrivate : public QValueAxisPrivate
             {
                 Q_OBJECT
             public:
                 QCategoryAxisPrivate(QCategoryAxis *q);
                 ~QCategoryAxisPrivate();
-            public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 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:
                 QMap<QString , Range> m_categoriesMap;
                 QStringList m_categories;
                 qreal m_categoryMinimum;
             private:
                 Q_DECLARE_PUBLIC(QCategoryAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORYAXIS_P_H

src/axis/datetimeaxis/qdatetimeaxis.cpp +2 -4

             /****************************************************************************
             **
             ** 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 "qdatetimeaxis.h"
             #include "qdatetimeaxis_p.h"
             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
             #include "domain_p.h"
             #include <cmath>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QDateTimeAxis
                 \brief The QDateTimeAxis class is used for manipulating chart's axis.
                 \mainclass
                 The labels can be configured by setting an appropriate DateTime format.
-                Note that any date before 4800 BCE or after about 1.4 million CE may not be accurately stored.
+                Note that any date before 4714 BCE or after about 1.4 million CE may not be accurately stored.
                 QDateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass DateTimeAxis QDateTimeAxis
                 \brief The DateTimeAxis element is used for manipulating chart's axes
                 The labels can be configured by setting an appropriate DateTime format.
-                Note that any date before 4800 BCE or after about 1.4 million CE may not be accurately stored.
+                Note that any date before 4714 BCE or after about 1.4 million CE may not be accurately stored.
                 DateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
               \property QDateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QDateTimeAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QDateTimeAxis::minChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::maxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::rangeChanged(QDateTime min, QDateTime max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QDateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValuesAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QDateTimeAxis::QDateTimeAxis(QObject *parent) :
                 QAbstractAxis(*new QDateTimeAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QDateTimeAxis::QDateTimeAxis(QDateTimeAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QDateTimeAxis::~QDateTimeAxis()
             {
             }
             void QDateTimeAxis::setMin(QDateTime min)
             {
                 Q_D(QDateTimeAxis);
                 if (min.isValid())
                     setRange(min, qMax(d->m_max, min));
             }
             QDateTime QDateTimeAxis::min() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_min;
             }
             void QDateTimeAxis::setMax(QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (max.isValid())
                     setRange(qMin(d->m_min, max), max);
             }
             QDateTime QDateTimeAxis::max() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QDateTimeAxis::setRange(QDateTime min, QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (!min.isValid() || !max.isValid() || min > max)
                     return;
                 bool changed = false;
                 if (d->m_min != min) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (d->m_max != max) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
-                //        if(d->m_niceNumbers) d->looseNiceNumbers(d->m_min, d->m_max, d->m_tickCount);
                 if (changed) {
                     emit rangeChanged(d->m_min,d->m_max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a format string that is used when creating label for the axis out of the QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
               \sa format()
             */
             void QDateTimeAxis::setFormat(QString format)
             {
                 Q_D(QDateTimeAxis);
                 d->m_format = format;
             }
             /*!
               Returns the format string that is used when creating label for the axis out of the QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
               \sa setFormat()
             */
             QString QDateTimeAxis::format() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_format;
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QDateTimeAxis::setTickCount(int count)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
               \fn int QDateTimeAxis::tickCount() const
               Return number of ticks on the axis
             */
             int QDateTimeAxis::tickCount() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_tickCount;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QDateTimeAxis::type() const
             {
                 return AxisTypeDateTime;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis* q):
                 QAbstractAxisPrivate(q),
                 m_tickCount(5)
             {
                 m_min = QDateTime::fromMSecsSinceEpoch(0);
                 m_max = QDateTime::fromMSecsSinceEpoch(0);
                 m_format = "dd-MMM-yyyy\nh:mm";
             }
             QDateTimeAxisPrivate::~QDateTimeAxisPrivate()
             {
             }
             void QDateTimeAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QDateTimeAxis);
                 Domain* domain = qobject_cast<Domain*>(sender());
                 Q_ASSERT(domain);
                 if(orientation()==Qt::Horizontal){
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
                 }else if(orientation()==Qt::Vertical){
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
                 }
             }
             void QDateTimeAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime))
                     q->setMin(min.toDateTime());
             }
             void QDateTimeAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (max.canConvert(QVariant::DateTime))
                     q->setMax(max.toDateTime());
             }
             void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime) && max.canConvert(QVariant::DateTime))
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
             ChartAxis* QDateTimeAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QDateTimeAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartDateTimeAxisY(q,presenter);
                 }else{
                     return new ChartDateTimeAxisX(q,presenter);
                 }
             }
             void QDateTimeAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QDateTimeAxis);
                 if(m_max == m_min) {
                     if(m_orientation==Qt::Vertical){
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
                     }else{
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
                     }
                 } else {
                     if(m_orientation==Qt::Vertical){
                         domain->setRangeY(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
                     }else{
                         domain->setRangeX(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
                     }
                 }
             }
             #include "moc_qdatetimeaxis.cpp"
             #include "moc_qdatetimeaxis_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