HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1816:57c485eadcaf

QIntervalsAxis renamed to QCategoryAxis

Marek Rosa -

r1816:57c485eadcaf

parent child

Context file:

r1816:57c485eadcaf

Collapse all files

examples/customchart/main.cpp +3 -3

             #include <QMainWindow>
             #include <QChartView>
             #include <QLineSeries>
-            #include <QIntervalsAxis>
+            #include <QCategoryAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //![2]
             //![3]
-                QIntervalsAxis* axisX = new QIntervalsAxis();
+                QCategoryAxis* axisX = new QCategoryAxis();
-                QIntervalsAxis* axisY = new QIntervalsAxis();
+                QCategoryAxis* axisY = new QCategoryAxis();
                 // Customize axis label font
                 QFont labelsFont;

src/axis/intervalsaxis/chartintervalsaxisx.cpp +2 -2

             QVector<qreal> ChartIntervalAxisX::calculateLayout() const
             {
-                QIntervalsAxis *axis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *axis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 int tickCount = axis->intervalsLabels().count() + 1;
                 QVector<qreal> points;
                 if(layout.isEmpty()) return;
-                QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();

src/axis/intervalsaxis/chartintervalsaxisy.cpp +2 -2

             QVector<qreal> ChartIntervalAxisY::calculateLayout() const
             {
-                QIntervalsAxis *axis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *axis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 int tickCount = axis->intervalsLabels().count() + 1;
                 QVector<qreal> points;
                 if(layout.isEmpty()) return;
-                QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();

src/axis/intervalsaxis/qintervalsaxis.cpp +30 -30

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
-                \class QIntervalsAxis
+                \class QCategoryAxis
-                \brief The QIntervalsAxis class is used for manipulating chart's axis.
+                \brief The QCategoryAxis class is used for manipulating chart's axis.
                 \mainclass
             */
             /*!
-                \qmlclass Axis QIntervalsAxis
+                \qmlclass Axis QCategoryAxis
                 \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.
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
-            QIntervalsAxis::QIntervalsAxis(QObject *parent):
+            QCategoryAxis::QCategoryAxis(QObject *parent):
-                QValueAxis(*new QIntervalsAxisPrivate(this),parent)
+                QValueAxis(*new QCategoryAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
-            QIntervalsAxis::~QIntervalsAxis()
+            QCategoryAxis::~QCategoryAxis()
             {
                 //    Q_D(QValueAxis);
                 //    if(d->m_dataset) {
             /*!
                 \internal
             */
-            QIntervalsAxis::QIntervalsAxis(QIntervalsAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
+            QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
             {
             }
                 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)
+            void QCategoryAxis::append(const QString& intervalLabel, qreal intervalEnd)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 if (!d->m_intervals.contains(intervalLabel))
                 {
             /*!
                 Sets to \a min the low end limit of the first interval on the axis.
             */
-            void QIntervalsAxis::setFisrtIntervalMinimum(qreal min)
+            void QCategoryAxis::setFisrtIntervalMinimum(qreal min)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 if(d->m_intervals.isEmpty()){
                     d->m_categoryMinimum = min;
                 }else{
             /*!
                 Returns the low end limit of the interval specified by an \a intervalLabel
             */
-            qreal QIntervalsAxis::intervalMin(const QString& intervalLabel) const
+            qreal QCategoryAxis::intervalMin(const QString& intervalLabel) const
             {
-                Q_D(const QIntervalsAxis);
+                Q_D(const QCategoryAxis);
                 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
+            qreal QCategoryAxis::intervalMax(const QString& intervalLabel) const
             {
-                Q_D(const QIntervalsAxis);
+                Q_D(const QCategoryAxis);
                 return d->m_intervalsMap.value(intervalLabel).second;
             }
             /*!
                 Removes an interval specified by the \a intervalLabel from the axis
             */
-            void QIntervalsAxis::remove(const QString &intervalLabel)
+            void QCategoryAxis::remove(const QString &intervalLabel)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 int labelIndex = d->m_intervals.indexOf(intervalLabel);
                 // check if such label exists
               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)
+            void QCategoryAxis::replaceLabel(const QString& oldLabel, const QString& newLabel)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 int labelIndex = d->m_intervals.indexOf(oldLabel);
                 // check if such label exists
             /*!
               Returns the list of the intervals labels
              */
-            QStringList QIntervalsAxis::intervalsLabels()
+            QStringList QCategoryAxis::intervalsLabels()
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 return d->m_intervals;
             }
             /*!
               Returns number of intervals.
              */
-            int QIntervalsAxis::count() const
+            int QCategoryAxis::count() const
             {
-                Q_D(const QIntervalsAxis);
+                Q_D(const QCategoryAxis);
                 return d->m_intervals.count();
             }
             /*!
               Returns the type of the axis
             */
-            QAbstractAxis::AxisType QIntervalsAxis::type() const
+            QAbstractAxis::AxisType QCategoryAxis::type() const
             {
                 return QAbstractAxis::AxisTypeIntervals;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QIntervalsAxisPrivate::QIntervalsAxisPrivate(QIntervalsAxis* q):
+            QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis* q):
                 QValueAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
-            QIntervalsAxisPrivate::~QIntervalsAxisPrivate()
+            QCategoryAxisPrivate::~QCategoryAxisPrivate()
             {
             }
-            int QIntervalsAxisPrivate::ticksCount() const
+            int QCategoryAxisPrivate::ticksCount() const
             {
                 return m_intervals.count() + 1;
             }
-            void QIntervalsAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
+            void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 Q_UNUSED(count);
                 Q_UNUSED(min);
                 //m_max = max;
             }
-            ChartAxis* QIntervalsAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis* QCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
-                Q_Q(QIntervalsAxis);
+                Q_Q(QCategoryAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartIntervalAxisY(q,presenter);
                 }else{

src/axis/intervalsaxis/qintervalsaxis.h +7 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QIntervalsAxisPrivate;
+            class QCategoryAxisPrivate;
-            class QTCOMMERCIALCHART_EXPORT QIntervalsAxis : public QValueAxis
+            class QTCOMMERCIALCHART_EXPORT QCategoryAxis : public QValueAxis
             {
                 Q_OBJECT
             public:
-                explicit QIntervalsAxis(QObject *parent = 0);
+                explicit QCategoryAxis(QObject *parent = 0);
-                ~QIntervalsAxis();
+                ~QCategoryAxis();
             protected:
-                QIntervalsAxis(QIntervalsAxisPrivate &d,QObject *parent = 0);
+                QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
             private:
-                Q_DECLARE_PRIVATE(QIntervalsAxis)
+                Q_DECLARE_PRIVATE(QCategoryAxis)
-                Q_DISABLE_COPY(QIntervalsAxis)
+                Q_DISABLE_COPY(QCategoryAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/intervalsaxis/qintervalsaxis_p.h +7 -7

             //
             // We mean it.
-            #ifndef QIntervalsAxis_P_H
+            #ifndef QCATEGORYAXIS_P_H
-            #define QIntervalsAxis_P_H
+            #define QCATEGORYAXIS_P_H
             #include "qintervalsaxis.h"
             #include "qvalueaxis_p.h"
             typedef QPair<qreal, qreal> Range;
-            class QIntervalsAxisPrivate : public QValueAxisPrivate
+            class QCategoryAxisPrivate : public QValueAxisPrivate
             {
                 Q_OBJECT
             public:
-                QIntervalsAxisPrivate(QIntervalsAxis *q);
+                QCategoryAxisPrivate(QCategoryAxis *q);
-                ~QIntervalsAxisPrivate();
+                ~QCategoryAxisPrivate();
             public:
                 qreal m_categoryMinimum;
             private:
-                Q_DECLARE_PUBLIC(QIntervalsAxis)
+                Q_DECLARE_PUBLIC(QCategoryAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif // QCATEGORIESAXIS_P_H
+            #endif // QCATEGORYAXIS_P_H

src/chartdataset.cpp +1 -1

                     axis = new QBarCategoryAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeIntervals:
-                    axis = new QIntervalsAxis(this);
+                    axis = new QCategoryAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);

tests/auto/qintervalsaxis/tst_qintervalsaxis.cpp +30 -30

             #include "qintervalsaxis.h"
             #include <qlineseries.h>
-            class tst_QIntervalsAxis: public tst_QAbstractAxis
+            class tst_QCategoryAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
                 void interval();
             private:
-                QIntervalsAxis* m_intervalsaxis;
+                QCategoryAxis* m_intervalsaxis;
                 QLineSeries* m_series;
             };
-            void tst_QIntervalsAxis::initTestCase()
+            void tst_QCategoryAxis::initTestCase()
             {
             }
-            void tst_QIntervalsAxis::cleanupTestCase()
+            void tst_QCategoryAxis::cleanupTestCase()
             {
             }
-            void tst_QIntervalsAxis::init()
+            void tst_QCategoryAxis::init()
             {
-                m_intervalsaxis = new QIntervalsAxis();
+                m_intervalsaxis = new QCategoryAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_intervalsaxis, m_series);
                 m_chart->createDefaultAxes();
             }
-            void tst_QIntervalsAxis::cleanup()
+            void tst_QCategoryAxis::cleanup()
             {
                 delete m_series;
                 delete m_intervalsaxis;
                 tst_QAbstractAxis::cleanup();
             }
-            void tst_QIntervalsAxis::qintervalsaxis_data()
+            void tst_QCategoryAxis::qintervalsaxis_data()
             {
             }
-            void tst_QIntervalsAxis::qintervalsaxis()
+            void tst_QCategoryAxis::qintervalsaxis()
             {
                 qabstractaxis();
                 QVERIFY(!qFuzzyIsNull(m_intervalsaxis->min()));
             }
-            void tst_QIntervalsAxis::max_raw_data()
+            void tst_QCategoryAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << 1.0;
                 QTest::newRow("101.0") << 101.0;
             }
-            void tst_QIntervalsAxis::max_raw()
+            void tst_QCategoryAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QCOMPARE(spy2.count(), 1);
             }
-            void tst_QIntervalsAxis::max_data()
+            void tst_QCategoryAxis::max_data()
             {
                 max_raw_data();
             }
-            void tst_QIntervalsAxis::max()
+            void tst_QCategoryAxis::max()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 max_raw();
             }
-            void tst_QIntervalsAxis::max_animation_data()
+            void tst_QCategoryAxis::max_animation_data()
             {
                 max_data();
             }
-            void tst_QIntervalsAxis::max_animation()
+            void tst_QCategoryAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
-            void tst_QIntervalsAxis::min_raw_data()
+            void tst_QCategoryAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << -1.0;
                 QTest::newRow("-101.0") << -101.0;
             }
-            void tst_QIntervalsAxis::min_raw()
+            void tst_QCategoryAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QCOMPARE(spy2.count(), 1);
             }
-            void tst_QIntervalsAxis::min_data()
+            void tst_QCategoryAxis::min_data()
             {
                 min_raw_data();
             }
-            void tst_QIntervalsAxis::min()
+            void tst_QCategoryAxis::min()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 min_raw();
             }
-            void tst_QIntervalsAxis::min_animation_data()
+            void tst_QCategoryAxis::min_animation_data()
             {
                 min_data();
             }
-            void tst_QIntervalsAxis::min_animation()
+            void tst_QCategoryAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
-            void tst_QIntervalsAxis::range_raw_data()
+            void tst_QCategoryAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
-            void tst_QIntervalsAxis::range_raw()
+            void tst_QCategoryAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QCOMPARE(spy2.count(), 1);
             }
-            void tst_QIntervalsAxis::range_data()
+            void tst_QCategoryAxis::range_data()
             {
                 range_raw_data();
             }
-            void tst_QIntervalsAxis::range()
+            void tst_QCategoryAxis::range()
             {
                 m_chart->setAxisX(m_intervalsaxis, m_series);
                 m_view->show();
                 range_raw();
             }
-            void tst_QIntervalsAxis::range_animation_data()
+            void tst_QCategoryAxis::range_animation_data()
             {
                 range_data();
             }
-            void tst_QIntervalsAxis::range_animation()
+            void tst_QCategoryAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
-            void tst_QIntervalsAxis::interval_data()
+            void tst_QCategoryAxis::interval_data()
             {
                 //
             }
-            void tst_QIntervalsAxis::interval()
+            void tst_QCategoryAxis::interval()
             {
                 // append one correct interval
                 m_intervalsaxis->append("first", (qreal)45);
                 QCOMPARE(m_intervalsaxis->intervalMax("replaced"), (qreal)75);
             }
-            QTEST_MAIN(tst_QIntervalsAxis)
+            QTEST_MAIN(tst_QCategoryAxis)
             #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