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

             /****************************************************************************
             **
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QLineSeries>
-            #include <QIntervalsAxis>
+            #include <QCategoryAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series = new QLineSeries();
                 *series << QPointF(0, 6) << QPointF(9, 4) << QPointF(15, 20) << QPointF(25, 12) << QPointF(29, 26);
                 QChart* chart = new QChart();
                 chart->legend()->hide();
                 chart->addSeries(series);
             //![1]
             //![2]
                 // Customize series
                 QPen pen(QRgb(0xfdb157));
                 pen.setWidth(5);
                 series->setPen(pen);
                 // Customize chart title
                 QFont font;
                 font.setPixelSize(18);
                 chart->setTitleFont(font);
                 chart->setTitleBrush(QBrush(Qt::white));
                 chart->setTitle("Customchart example");
                 // Customize chart background
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setStart(QPointF(0,0));
                 backgroundGradient.setFinalStop(QPointF(0,1));
                 backgroundGradient.setColorAt(0.0, QRgb(0xd2d0d1));
                 backgroundGradient.setColorAt(1.0, QRgb(0x4c4547));
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setBackgroundBrush(backgroundGradient);
             //![2]
             //![3]
-                QIntervalsAxis* axisX = new QIntervalsAxis();
+                QCategoryAxis* axisX = new QCategoryAxis();
-                QIntervalsAxis* axisY = new QIntervalsAxis();
+                QCategoryAxis* axisY = new QCategoryAxis();
                 // Customize axis label font
                 QFont labelsFont;
                 labelsFont.setPixelSize(12);
                 axisX->setLabelsFont(labelsFont);
                 axisY->setLabelsFont(labelsFont);
                 // Customize axis colors
                 QPen axisPen(QRgb(0xd18952));
                 axisPen.setWidth(2);
                 axisX->setAxisPen(axisPen);
                 axisY->setAxisPen(axisPen);
                 // Customize axis label colors
                 QBrush axisBrush(Qt::white);
                 axisX->setLabelsBrush(axisBrush);
                 axisY->setLabelsBrush(axisBrush);
                 // Customize grid lines and shades
                 axisX->setGridLineVisible(false);
                 axisY->setGridLineVisible(false);
                 axisY->setShadesPen(Qt::NoPen);
                 axisY->setShadesBrush(QBrush(QRgb(0xa5a2a3)));
                 axisY->setShadesVisible(true);
             //![3]
             //![4]
                 axisX->append("low", 10);
                 axisX->append("optimal", 20);
                 axisX->append("high", 30);
                 axisX->setRange(0, 30);
                 axisY->append("slow", 10);
                 axisY->append("med", 20);
                 axisY->append("fast", 30);
                 axisY->setRange(0, 30);
                 chart->setAxisX(axisX, series);
                 chart->setAxisY(axisY, series);
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

src/axis/intervalsaxis/chartintervalsaxisx.cpp +2 -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$
             **
             ****************************************************************************/
             #include "chartintervalsaxisx_p.h"
             #include "qintervalsaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartIntervalAxisX::ChartIntervalAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartIntervalAxisX::~ChartIntervalAxisX()
             {
             }
             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 (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.width() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int x = axis->intervalMin(axis->intervalsLabels().at(i)) * scale + m_rect.left();
                         points[i] = x;
                     } else {
                         int x = axis->intervalMax(axis->intervalsLabels().at(i - 1))  * scale + m_rect.left();
                         points[i] = x;
                     }
                 return points;
             }
             void ChartIntervalAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();
                 //    createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 //    qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < ticksList.count())
                         labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), m_rect.bottom() + label_padding);
                     else
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                     if(labelItem->pos().x() > m_rect.width() + m_rect.left() - rect.width() / 2){
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     m_minWidth += rect.width();
                     m_minHeight = qMax(rect.height(), m_minHeight);
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1],m_rect.top(),layout[i]-layout[i - 1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i], m_rect.bottom() + 5);
                 }
             }
             void ChartIntervalAxisX::handleAxisUpdated()
             {
                 updateGeometry();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/intervalsaxis/chartintervalsaxisy.cpp +2 -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$
             **
             ****************************************************************************/
             #include "chartintervalsaxisy_p.h"
             #include "qintervalsaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartIntervalAxisY::ChartIntervalAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartIntervalAxisY::~ChartIntervalAxisY()
             {
             }
             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 (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.height() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int y = -axis->intervalMin(axis->intervalsLabels().at(i)) * scale + m_rect.bottom();
                         points[i] = y;
                     } else {
                         int y = -axis->intervalMax(axis->intervalsLabels().at(i - 1))  * scale + m_rect.bottom();
                         points[i] = y;
                     }
                 return points;
             }
             void ChartIntervalAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
+                QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < ticksList.count())
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
                     else
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                     if(labelItem->pos().y()+rect.height()>height) {
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         lineItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
                     m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartIntervalAxisY::handleAxisUpdated()
             {
                 updateGeometry();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** 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
             /*!
-                \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.
                 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):
+            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) {
                 //        d->m_dataset->removeAxis(this);
                 //    }
             }
             /*!
                 \internal
             */
-            QIntervalsAxis::QIntervalsAxis(QIntervalsAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
+            QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
             {
             }
             /*!
                 Appends new interval to the axis with an \a intervalLabel.
                 Interval label has to be unique.
                 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)
+            void QCategoryAxis::append(const QString& intervalLabel, qreal intervalEnd)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 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)
+            void QCategoryAxis::setFisrtIntervalMinimum(qreal min)
             {
-                Q_D(QIntervalsAxis);
+                Q_D(QCategoryAxis);
                 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
+            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
                 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)
+            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
                 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()
+            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);
                 Q_UNUSED(max);
                 //m_min = 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{
                     return new ChartIntervalAxisX(q,presenter);
                 }
             }
             #include "moc_qintervalsaxis.cpp"
             #include "moc_qintervalsaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** 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 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;
                 void append(const QString& label, qreal intervalEnd);
                 void remove(const QString& label);
                 void replaceLabel(const QString& oldLabel, const QString& newLabel);
                 void setFisrtIntervalMinimum(qreal min);
                 qreal intervalMin(const QString& intervalLabel) const;
                 qreal intervalMax(const QString& intervalLabel) const;
                 QStringList intervalsLabels();
                 int count() const;
             private:
-                Q_DECLARE_PRIVATE(QIntervalsAxis)
+                Q_DECLARE_PRIVATE(QCategoryAxis)
-                Q_DISABLE_COPY(QIntervalsAxis)
+                Q_DISABLE_COPY(QCategoryAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_H

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

             /****************************************************************************
             **
             ** 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 QIntervalsAxis_P_H
+            #ifndef QCATEGORYAXIS_P_H
-            #define QIntervalsAxis_P_H
+            #define QCATEGORYAXIS_P_H
             #include "qintervalsaxis.h"
             #include "qvalueaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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:
                 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_intervalsMap;
                 QStringList m_intervals;
                 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

             /****************************************************************************
             **
             ** 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 "chartdataset_p.h"
             #include "qchart.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis_p.h"
             #include "qintervalsaxis.h"
             #include "qdatetimeaxis.h"
             #include "qabstractseries_p.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(domain) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 createSeriesIndex(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 if(!m_seriesDomainMap.contains(series)) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 Domain* domain = m_seriesDomainMap.take(series);
                 delete domain;
                 domain = 0;
                 removeSeriesIndex(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 removeAxes(series);
             }
             void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
             }
             void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
             {
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesDomainMap.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     removeAxes(i.key());
                 }
                 i.toFront();
                 // Select the required axis x and axis y types based on the types of the current series
                 while (i.hasNext()) {
                     i.next();
                     QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                     QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                     if(axisX) typeX&=axisX->type();
                     else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
                     if(axisY) typeY&=axisY->type();
                     else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 // Create the axes of the types selected
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 // TODO: Add a descriptive comment of what happens here
                 if (type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories)) {
                     while (i.hasNext()) {
                         i.next();
                         QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation);
                         if (axis) {
                             initializeAxis(axis, i.key());
                             emit axisAdded(axis, i.value());
                         }
                     }
                 } else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation);
                     i.toFront();
                     while (i.hasNext()) {
                         i.next();
                         initializeAxis(axis,i.key());
                     }
                     emit axisAdded(axis,i.value());
                 }
             }
             QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation)
             {
                 QAbstractAxis* axis = 0;
                 switch(type) {
                 case QAbstractAxis::AxisTypeValues:
                     axis = new QValueAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeCategories:
                     axis = new QBarCategoryAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeIntervals:
-                    axis = new QIntervalsAxis(this);
+                    axis = new QCategoryAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
                 default:
                     axis = 0;
                     break;
                 }
                 if(axis)
                     axis->d_ptr->setOrientation(orientation);
                 return axis;
             }
             void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 axis->d_ptr->m_dataset = this;
                 series->d_ptr->initializeAxis(axis);
                 axis->d_ptr->intializeDomain(domain);
                 if(axis->orientation()==Qt::Horizontal) {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisXMap.insert(series,axis);
                 }
                 else {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisYMap.insert(series,axis);
                 }
                 axis->d_ptr->emitUpdated();
             }
             void ChartDataSet::removeAxes(QAbstractSeries* series)
             {
                 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
                 if(axisX) {
                     QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                     int x = axesX.indexOf(axisX);
                     if(x==-1) {
                         emit axisRemoved(axisX);
                         axisX->d_ptr->m_dataset=0;
                         axisX->deleteLater();
                     }
                 }
                 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
                 if(axisY) {
                     QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                     int y = axesY.indexOf(axisY);
                     if(y==-1) {
                         emit axisRemoved(axisY);
                         axisY->d_ptr->m_dataset=0;
                         axisY->deleteLater();
                     }
                 }
             }
             void ChartDataSet::removeAxis(QAbstractAxis* axis)
             {
                 if(!axis->d_ptr->m_dataset) {
                     qWarning()<<"UnBound axis found !";
                     return;
                 }
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(axis->orientation()==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }
                 else {
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==axis) {
                         removeSeries(i.key());
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
                 foreach(QAbstractSeries *s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesDomainMap.count()==0);
                 qDeleteAll(series);
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
                 blockAxisSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
                 blockAxisSignals(false);
             }
             void ChartDataSet::blockAxisSignals(bool enabled)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                     QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                     if(axisX) {
                         axisX->d_ptr->blockSignals(enabled);
                         if(!enabled) {
                             axisX->d_ptr->setDirty(false);
                             axisX->d_ptr->emitUpdated();
                         }
                     }
                     if(axisY) {
                         axisY->d_ptr->blockSignals(enabled);
                         if(!enabled) {
                             axisY->d_ptr->setDirty(false);
                             axisY->d_ptr->emitUpdated();
                         }
                     }
                 }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
             {
                 if(series == 0) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
             {
                 Q_ASSERT(axis);
                 if(!series) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 axis->d_ptr->setOrientation(orientation);
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(orientation==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }else{
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 if (seriesAxisMap->value(series) == axis) {
                     qWarning() << "The axis already set for the series";
                     return;
                 }
                 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
                 QList<QAbstractAxis*> axes = seriesAxisMap->values();
                 if(oldAxis) {
                     if(axes.indexOf(oldAxis)==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->disconnect();
                         QObject::disconnect(domain,0,oldAxis,0);
                         oldAxis->d_ptr->m_dataset=0;
                         oldAxis->deleteLater();
                     }
                 }
                 if(axes.indexOf(axis)==-1) {
                     initializeAxis(axis,series);
                     emit axisAdded(axis,domain);
                 }else{
                     initializeAxis(axis,series);
                 }
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
                 return m_seriesDomainMap.value(series);
             }
             void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->move(dx,dy,size);
                 }
                 blockAxisSignals(false);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesDomainMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
              **
              ** 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
+            class tst_QCategoryAxis: 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;
+                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->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
-            void tst_QIntervalsAxis::cleanup()
+            void tst_QCategoryAxis::cleanup()
             {
                 delete m_series;
                 delete m_intervalsaxis;
                 m_series = 0;
                 m_intervalsaxis = 0;
                 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->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()
+            void tst_QCategoryAxis::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()
+            void tst_QCategoryAxis::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()
+            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();
                 QTest::qWaitForWindowShown(m_view);
                 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("-50.0") << -50.0;
                 QTest::newRow("-101.0") << -101.0;
             }
-            void tst_QIntervalsAxis::min_raw()
+            void tst_QCategoryAxis::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()
+            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();
                 QTest::qWaitForWindowShown(m_view);
                 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("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()
+            void tst_QCategoryAxis::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()
+            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();
                 QTest::qWaitForWindowShown(m_view);
                 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->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->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)
+            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