HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1887:e0460f4395dd

Axis docs updated

Marek Rosa -

r1887:e0460f4395dd

parent child

Context file:

r1887:e0460f4395dd

Collapse all files

doc/images/api_datatime_axis.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

src/axis/categoryaxis/qcategoryaxis.cpp +15 0

             /****************************************************************************
             **
             ** 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 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.
+                Example code on how to use QCategoryAxis.
+                \code
+                QChartView *chartView = new QChartView;
+                QLineSeries *series = new QLineSeries;
+                // ...
+                chartView->chart()->addSeries(series);
+                QCategoryAxis *axisX = new QCategoryAxis;
+                axisX->setStartValue(15);
+                axisX->append("First", 20);
+                axisX->append("Second", 37);
+                axisX->append("Third", 52);
+                chartView->chart()->setAxisX(series, axisX);
+                \endcode
             */
             /*!
                 \qmlclass CategoryAxis QCategoryAxis
                 \inherits AbstractAxis
                 \brief CategoryAxis allows putting a named ranges on the axis.
                 For example:
                 \code
                     CategoryAxis {
                         startValue: 0.0
                         CategoryRange { endValue: 1.0; label: "min (0-1)" }
                         CategoryRange { endValue: 3.0; label: "standard (1-3)" }
                         CategoryRange { endValue: 4.0; label: "high (3-4)" }
                     }
                 \endcode
             */
             /*!
               \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)
             {
             }
             /*!
                 \qmlmethod CategoryAxis::append(string label, real endValue)
                 Appends new category to the axis with an \a label. Category label has to be unique.
                 Parameter \a endValue 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.
             */
             /*!
                 Appends new category to the axis with an \a categoryLabel.
                 Category label has to be unique.
                 Parameter \a categoryEndValue 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 categoryEndValue)
             {
                 Q_D(QCategoryAxis);
                 if (!d->m_categories.contains(categoryLabel))
                 {
                     if(d->m_categories.isEmpty()){
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
                     }else if (categoryEndValue > endValue(d->m_categories.last())){
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryEndValue));
                         d->m_categories.append(categoryLabel);
                     }
                 }
             }
             /*!
                 Sets \a min to be the low end limit of the first category on the axis.
                 If there is already some categories added to the axis then passed value must be lower than the high end value of the already defined first category range.
                 Otherwise nothing is done.
             */
             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());
                     if (min < range.second)
                         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::startValue(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 if (categoryLabel == QString())
                     return d->m_categoryMinimum;
                 else
                     return d->m_categoriesMap.value(categoryLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
             qreal QCategoryAxis::endValue(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
             }
             /*!
                 \qmlmethod CategoryAxis::remove(string label)
                 Removes a category specified by the \a label from the axis
             */
             /*!
                 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();
                 }
             }
             /*!
               \qmlmethod CategoryAxis::replace(string oldLabel, string newLabel)
               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.
             */
             /*!
               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/datetimeaxis/qdatetimeaxis.cpp +3 -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 "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 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.
+                \image api_datatime_axis.png
                 Example code on how to use QDateTimeAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QLineSeries *series = new QLineSeries;
                 QDateTime xValue;
                 xValue.setDate(QDate(2012, 1 , 18));
                 xValue.setTime(QTime(9, 34));
                 series->append(xValue.toMSecsSinceEpoch(), 12);
                 xValue.setDate(QDate(2013, 5 , 11));
                 xValue.setTime(QTime(11, 14));
                 series->append(xValue.toMSecsSinceEpoch(), 22);
                 chartView->chart()->addSeries(series);
                 // ...
                 QDateTimeAxis *axisX = new QDateTimeAxis;
                 axisX->setFormat("dd-MM-yyyy h:mm");
                 chartView->chart()->setAxisX(series, axisX);
                 \endcode
             */
             /*!
                 \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 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 (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";
+                m_format = "dd-MM-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