HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1800:0d55302d18fc

Some interval axis docs updates

Marek Rosa -

r1800:0d55302d18fc

parent child

Context file:

r1800:0d55302d18fc

Collapse all files

doc/src/classes.qdoc +1 0

             /*!
                 \page classes.html
                 \title QtCommercial Charts API
                 \keyword All Classes
                 Charts API is build on top of Qt Graphics View Framework. Charts can be displayed as QGraphicsWidget using QChart class. However
                 there is also convenience class QChartView which is QWidget based. These lets quickly use QCharts as normal Qt widget.
                 Each chart type is represented by QAbstractSeries derived class. To create given chart type users have to use instance of related series class and add it to QChart instance.
                 \code
                 QLineSeries* series = new QLineSeries();
                 series->add(0, 6);
                 series->add(2, 4);
                 ...
                 chartView->chart()->addSeries(series);
                 chartView->chart()->createDefaultAxes();
                 \endcode
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%">
                                 Common and global
                             </th>
                             <th class="titleheader" width="25%">
                                 XY chart
                             </th>
                         </tr>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qchart.html">QChart</a></li>
                                 <li><a href="qchartview.html">QChartView</a></li>
                                 <li><a href="qabstractaxis.html">QAbstractAxis</a></li>
                                 <li><a href="qvaluesaxis.html">QValuesAxis</a></li>
                                 <li><a href="qbarcategoriesaxis.html">QBarCategoriesAxis</a></li>
+                                <li><a href="qintervalsaxis.html">QIntervalsAxis</a></li>
                                 <li><a href="qlegend.html">QLegend</a></li>
                                 <li><a href="qabstractseries.html">QAbstractSeries</a></li>
                                 <li><a href="qchartglobal.html">QChartGlobal</a></li>
                                 </ul>
                             </td>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qxyseries.html">QXYSeries</a></li>
                                 <li><a href="qlineseries.html">QLineSeries</a></li>
                                 <li><a href="qareaseries.html">QAreaSeries</a></li>
                                 <li><a href="qscatterseries.html">QScatterSeries</a></li>
                                 <li><a href="qsplineseries.html">QSplineSeries</a></li>
                                 <li><a href="qhxymodelmapper.html">QHXYModelMapper</a></li>
                                 <li><a href="qvxymodelmapper.html">QVXYModelMapper</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%">
                                 Pie chart
                             </th>
                             <th class="titleheader" width="25%">
                                 Bar chart
                             </th>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qpieseries.html">QPieSeries</a></li>
                                 <li><a href="qpieslice.html">QPieSlice</a></li>
                                 <li><a href="qhpiemodelmapper.html">QHPieModelMapper</a></li>
                                 <li><a href="qvpiemodelmapper.html">QVPieModelMapper</a></li>
                                 </ul>
                             </td>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qbarseries.html">QBarSeries</a></li>
                                 <li><a href="qbarset.html">QBarSet</a></li>
                                 <li><a href="qpercentbarseries.html">QPercentBarSeries</a></li>
                                 <li><a href="qstackedbarseries.html">QStackedBarSeries</a></li>
                                 <li><a href="qhbarmodelmapper.html">QHBarModelMapper</a></li>
                                 <li><a href="qvbarmodelmapper.html">QVBarModelMapper</a></li>
                                 <li><a href="qhorizontalbarseries.html">QHorizontalBarSeries</a></li>
                                 <li><a href="qhorizontalstackedbarseries.html">QHorizontalStackedBarSeries</a></li>
                                 <li><a href="qhorizontalpercentbarseries.html">QHorizontalPercentBarSeries</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                 \endraw
             */

src/axis/intervalsaxis/qintervalsaxis.cpp +9 -5

             /****************************************************************************
             **
             ** 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 "qintervalsaxis.h"
             #include "qintervalsaxis_p.h"
             #include "chartintervalsaxisx_p.h"
             #include "chartintervalsaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
-                \internal
                 \class QIntervalsAxis
                 \brief The QIntervalsAxis class is used for manipulating chart's axis.
                 \mainclass
-                Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QIntervalsAxis
                 \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.
                 To access Axes you can use ChartView API. For example:
                 \code
                 // TODO :)
                 \endcode
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QIntervalsAxis::QIntervalsAxis(QObject *parent):
                 QValuesAxis(*new QIntervalsAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QIntervalsAxis::~QIntervalsAxis()
             {
                 //    Q_D(QValuesAxis);
                 //    if(d->m_dataset) {
                 //        d->m_dataset->removeAxis(this);
                 //    }
             }
             /*!
                 \internal
             */
             QIntervalsAxis::QIntervalsAxis(QIntervalsAxisPrivate &d,QObject *parent):QValuesAxis(d,parent)
             {
             }
             /*!
                 Appends new interval to the axis with an \a intervalLabel.
                 Interval label has to be unique.
-                Parameter \a interval specifies the high end limit of the interval.
+                Parameter \a intervalEnd specifies the high end limit of the interval.
                 It has to be greater than the high end limit of the previous interval.
                 Otherwise the method returns without adding a new interval.
             */
             void QIntervalsAxis::append(const QString& intervalLabel, qreal intervalEnd)
             {
                 Q_D(QIntervalsAxis);
                 if (!d->m_intervals.contains(intervalLabel))
                 {
                     if(d->m_intervals.isEmpty()){
                         Range range(d->m_categoryMinimum, intervalEnd);
                         d->m_intervalsMap.insert(intervalLabel, range);
                         d->m_intervals.append(intervalLabel);
                     }else if (intervalEnd > intervalMax(d->m_intervals.last())){
                         Range range = d->m_intervalsMap.value(d->m_intervals.last());
                         d->m_intervalsMap.insert(intervalLabel, Range(range.second, intervalEnd));
                         d->m_intervals.append(intervalLabel);
                     }
                 }
             }
             /*!
                 Sets to \a min the low end limit of the first interval on the axis.
             */
             void QIntervalsAxis::setFisrtIntervalMinimum(qreal min)
             {
                 Q_D(QIntervalsAxis);
                 if(d->m_intervals.isEmpty()){
                     d->m_categoryMinimum = min;
                 }else{
                     Range range = d->m_intervalsMap.value(d->m_intervals.first());
                     d->m_intervalsMap.insert(d->m_intervals.first(), Range(min, range.second));
                 }
             }
             /*!
                 Returns the low end limit of the interval specified by an \a intervalLabel
             */
             qreal QIntervalsAxis::intervalMin(const QString& intervalLabel) const
             {
                 Q_D(const QIntervalsAxis);
                 return d->m_intervalsMap.value(intervalLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a intervalLabel
             */
             qreal QIntervalsAxis::intervalMax(const QString& intervalLabel) const
             {
                 Q_D(const QIntervalsAxis);
                 return d->m_intervalsMap.value(intervalLabel).second;
             }
             /*!
-                Removes \a interval from axis
+                Removes an interval specified by the \a intervalLabel from the axis
             */
             void QIntervalsAxis::remove(const QString &intervalLabel)
             {
                 Q_D(QIntervalsAxis);
                 int labelIndex = d->m_intervals.indexOf(intervalLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_intervals.removeAt(labelIndex);
                     d->m_intervalsMap.remove(intervalLabel);
                     // the range of the interval that follows (if exists) needs to be updated
                     if (labelIndex < d->m_intervals.count()) {
                         QString label = d->m_intervals.at(labelIndex);
                         Range range = d->m_intervalsMap.value(label);
                         // set the range
                         if (labelIndex == 0) {
                             range.first = d->m_categoryMinimum;
                             d->m_intervalsMap.insert(label, range);
                         } else {
                             range.first = d->m_intervalsMap.value(d->m_intervals.at(labelIndex - 1)).second;
                             d->m_intervalsMap.insert(label, range);
                         }
                     }
                     d->emitUpdated();
                 }
             }
+            /*!
+              Replaces \a oldLabel of an existing interval with a \a newLabel
+              If the old label does not exist the method returns without making any changes.
+             */
             void QIntervalsAxis::replaceLabel(const QString& oldLabel, const QString& newLabel)
             {
                 Q_D(QIntervalsAxis);
                 int labelIndex = d->m_intervals.indexOf(oldLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_intervals.replace(labelIndex, newLabel);
                     Range range = d->m_intervalsMap.value(oldLabel);
                     d->m_intervalsMap.remove(oldLabel);
                     d->m_intervalsMap.insert(newLabel, range);
                     d->emitUpdated();
                 }
             }
+            /*!
+              Returns the list of the intervals labels
+             */
             QStringList QIntervalsAxis::intervalsLabels()
             {
                 Q_D(QIntervalsAxis);
                 return d->m_intervals;
             }
             /*!
               Returns number of intervals.
              */
             int QIntervalsAxis::count() const
             {
                 Q_D(const QIntervalsAxis);
                 return d->m_intervals.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QIntervalsAxis::type() const
             {
                 return QAbstractAxis::AxisTypeIntervals;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QIntervalsAxisPrivate::QIntervalsAxisPrivate(QIntervalsAxis* q):
                 QValuesAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
             QIntervalsAxisPrivate::~QIntervalsAxisPrivate()
             {
             }
             int QIntervalsAxisPrivate::ticksCount() const
             {
                 return m_intervals.count() + 1;
             }
             void QIntervalsAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 Q_UNUSED(count);
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 //m_min = min;
                 //m_max = max;
             }
             ChartAxis* QIntervalsAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QIntervalsAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartIntervalAxisY(q,presenter);
                 }else{
                     return new ChartIntervalAxisX(q,presenter);
                 }
             }
             #include "moc_qintervalsaxis.cpp"
             #include "moc_qintervalsaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qintervalsaxis/tst_qintervalsaxis.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 "../qabstractaxis/tst_qabstractaxis.h"
             #include "qintervalsaxis.h"
             #include <qlineseries.h>
             class tst_QIntervalsAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qintervalsaxis_data();
                 void qintervalsaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void interval_data();
                 void interval();
             private:
                 QIntervalsAxis* m_intervalsaxis;
                 QLineSeries* m_series;
             };
             void tst_QIntervalsAxis::initTestCase()
             {
             }
             void tst_QIntervalsAxis::cleanupTestCase()
             {
             }
             void tst_QIntervalsAxis::init()
             {
                 m_intervalsaxis = new QIntervalsAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_intervalsaxis, m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QIntervalsAxis::cleanup()
             {
                 delete m_series;
                 delete m_intervalsaxis;
                 m_series = 0;
                 m_intervalsaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QIntervalsAxis::qintervalsaxis_data()
             {
             }
             void tst_QIntervalsAxis::qintervalsaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyIsNull(m_intervalsaxis->max()));
                 QVERIFY(qFuzzyIsNull(m_intervalsaxis->min()));
                 QCOMPARE(m_intervalsaxis->type(), QAbstractAxis::AxisTypeIntervals);
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyIsNull(m_intervalsaxis->max()));
                 QVERIFY(!qFuzzyIsNull(m_intervalsaxis->min()));
             }
             void tst_QIntervalsAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << 1.0;
                 QTest::newRow("50.0") << 50.0;
                 QTest::newRow("101.0") << 101.0;
             }
             void tst_QIntervalsAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_intervalsaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_intervalsaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_intervalsaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_intervalsaxis->setMax(max);
                 QVERIFY2(qFuzzyIsNull(m_intervalsaxis->max() - max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QIntervalsAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QIntervalsAxis::max()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QIntervalsAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QIntervalsAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QIntervalsAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << -1.0;
                 QTest::newRow("-50.0") << -50.0;
                 QTest::newRow("-101.0") << -101.0;
             }
             void tst_QIntervalsAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_intervalsaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_intervalsaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_intervalsaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_intervalsaxis->setMin(min);
                 QVERIFY2(qFuzzyIsNull(m_intervalsaxis->min() - min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QIntervalsAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QIntervalsAxis::min()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QIntervalsAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QIntervalsAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QIntervalsAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << -1.0 << 101.0;
                 QTest::newRow("25.0 - 75.0") << 25.0 << 75.0;
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
             void tst_QIntervalsAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_intervalsaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_intervalsaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_intervalsaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_intervalsaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_intervalsaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_intervalsaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QIntervalsAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QIntervalsAxis::range()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QIntervalsAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QIntervalsAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QIntervalsAxis::interval_data()
             {
                 //
             }
             void tst_QIntervalsAxis::interval()
             {
                 // append one correct interval
                 m_intervalsaxis->append("first", (qreal)45);
                 QCOMPARE(m_intervalsaxis->intervalMin("first"), (qreal)0);
                 QCOMPARE(m_intervalsaxis->intervalMax("first"), (qreal)45);
                 // append one more correct interval
                 m_intervalsaxis->append("second", (qreal)75);
                 QCOMPARE(m_intervalsaxis->intervalMin("second"), (qreal)45);
                 QCOMPARE(m_intervalsaxis->intervalMax("second"), (qreal)75);
                 // append one incorrect interval
                 m_intervalsaxis->append("third", (qreal)15);
                 QCOMPARE(m_intervalsaxis->count(), 2);
                 QCOMPARE(m_intervalsaxis->intervalMax(m_intervalsaxis->intervalsLabels().last()), (qreal)75);
             //    QCOMPARE(intervalMax("first"), (qreal)75);
                 // append one more correct interval
                 m_intervalsaxis->append("third", (qreal)100);
                 QCOMPARE(m_intervalsaxis->count(), 3);
                 QCOMPARE(m_intervalsaxis->intervalMin("third"), (qreal)75);
                 QCOMPARE(m_intervalsaxis->intervalMax("third"), (qreal)100);
                 // remove one interval
                 m_intervalsaxis->remove("first");
                 QCOMPARE(m_intervalsaxis->count(), 2);
                 QCOMPARE(m_intervalsaxis->intervalMin("second"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_intervalsaxis->intervalMax("second"), (qreal)75);
                 // remove one interval
-                m_intervalsaxis->replace("second", "replaced");
+                m_intervalsaxis->replaceLabel("second", "replaced");
                 QCOMPARE(m_intervalsaxis->count(), 2);
                 QCOMPARE(m_intervalsaxis->intervalMin("replaced"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_intervalsaxis->intervalMax("replaced"), (qreal)75);
             }
             QTEST_MAIN(tst_QIntervalsAxis)
             #include "tst_qintervalsaxis.moc"

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