HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1807:d572c33906e7

QValueAxis ticksCount to tickCount

Marek Rosa -

r1807:d572c33906e7

parent child

Context file:

r1807:d572c33906e7

Collapse all files

demos/dynamicspline/chart.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 "chart.h"
             #include <QAbstractAxis>
             #include <QSplineSeries>
             #include <QValueAxis>
             #include <QTime>
             #include <QDebug>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags):
                 QChart(parent, wFlags),
                 m_series(0),
                 m_axis(new QValueAxis),
                 m_step(0),
                 m_x(5),
                 m_y(1)
             {
                 qsrand((uint) QTime::currentTime().msec());
                 QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
                 m_timer.setInterval(1000);
                 m_series = new QSplineSeries(this);
                 QPen green(Qt::red);
                 green.setWidth(3);
                 m_series->setPen(green);
                 m_series->append(m_x, m_y);
                 addSeries(m_series);
                 createDefaultAxes();
                 setAxisX(m_axis,m_series);
-                m_axis->setTicksCount(5);
+                m_axis->setTickCount(5);
                 axisX()->setRange(0, 10);
                 axisY()->setRange(-5, 10);
                 m_timer.start();
             }
             Chart::~Chart()
             {
             }
             void Chart::handleTimeout()
             {
-                qreal x = plotArea().width()/m_axis->ticksCount();
+                qreal x = plotArea().width()/m_axis->tickCount();
-                qreal y =(m_axis->max() - m_axis->min())/m_axis->ticksCount();
+                qreal y =(m_axis->max() - m_axis->min())/m_axis->tickCount();
                 m_x += y;
                 m_y = qrand() % 5 - 2.5;
                 m_series->append(m_x, m_y);
                 scroll(x,0);
                 if(m_x==100) m_timer.stop();
             }

src/axis/valueaxis/chartvalueaxisx.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 "chartvalueaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartValueAxisX::~ChartValueAxisX()
             {
             }
             QVector<qreal> ChartValueAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaX = m_rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 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));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         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 ChartValueAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
-                m_tickCount = axis->ticksCount();
+                m_tickCount = axis->tickCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy.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 "chartvalueaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartValueAxisY::~ChartValueAxisY()
             {
             }
             QVector<qreal> ChartValueAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaY = m_rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int y = i * -deltaY + m_rect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 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());
                 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));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         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 ChartValueAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
-                m_tickCount = axis->ticksCount();
+                m_tickCount = axis->tickCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.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 "qvalueaxis.h"
             #include "qvalueaxis_p.h"
             #include "chartvalueaxisx_p.h"
             #include "chartvalueaxisy_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValueAxis
                 \brief The QValueAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValuesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
             */
             /*!
                 \qmlclass ValuesAxis QValueAxis
                 \brief The ValuesAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValuesAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(real min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValueAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(real max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValueAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValueAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValueAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool ValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValueAxis::QValueAxis(QObject *parent) :
                 QAbstractAxis(*new QValueAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QValueAxis::QValueAxis(QValueAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValueAxis::~QValueAxis()
             {
                 Q_D(QValueAxis);
                 if(d->m_dataset) {
                     d->m_dataset->removeAxis(this);
                 }
             }
             void QValueAxis::setMin(qreal min)
             {
                 Q_D(QValueAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QValueAxis::min() const
             {
                 Q_D(const QValueAxis);
                 return d->m_min;
             }
             void QValueAxis::setMax(qreal max)
             {
                 Q_D(QValueAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QValueAxis::max() const
             {
                 Q_D(const QValueAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QValueAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValueAxis);
                 bool changed = false;
                 if (min > max) return;
                 if(d->m_niceNumbers) {
                     int ticks = d->m_tickCount;
                     d->looseNiceNumbers(min, max, ticks);
-                    if(ticks!=d->m_tickCount) setTicksCount(ticks);
+                    if(ticks!=d->m_tickCount) setTickCount(ticks);
                 }
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(min,max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
-            void QValueAxis::setTicksCount(int count)
+            void QValueAxis::setTickCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
               \fn int QValueAxis::ticksCount() const
               Return number of ticks on the axis
             */
-            int QValueAxis::ticksCount() const
+            int QValueAxis::tickCount() const
             {
                 Q_D(const QValueAxis);
                 return d->m_tickCount;
             }
             void QValueAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValueAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     if(enable && !qFuzzyIsNull(d->m_max - d->m_min)) {
                         setRange(d->m_min,d->m_max);
                     }
                 }
             }
             bool  QValueAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValueAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValueAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0),
                 m_max(0),
                 m_tickCount(5),
                 m_niceNumbers(false)
             {
             }
             QValueAxisPrivate::~QValueAxisPrivate()
             {
             }
             void QValueAxisPrivate::handleDomainUpdated()
             {
                Q_Q(QValueAxis);
                Domain* domain = qobject_cast<Domain*>(sender());
                Q_ASSERT(domain);
                if(orientation()==Qt::Horizontal){
                    q->setRange(domain->minX(),domain->maxX());
                }else if(orientation()==Qt::Vertical){
                    q->setRange(domain->minY(),domain->maxY());
                }
             }
             void QValueAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValueAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             ChartAxis* QValueAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValueAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValueAxisY(q,presenter);
                 }else{
                     return new ChartValueAxisX(q,presenter);
                 }
             }
             void QValueAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QValueAxis);
                 if(qFuzzyCompare(m_max,m_min)) {
                     if(m_orientation==Qt::Vertical){
                         q->setRange(domain->minY(),domain->maxY());
                     }else{
                         q->setRange(domain->minX(), domain->maxX());
                     }
                 } else {
                     if(m_orientation==Qt::Vertical){
                         domain->setRangeY(m_min, m_max);
                     }else{
                         domain->setRangeX(m_min, m_max);
                     }
                 }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void QValueAxisPrivate::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const
             {
                 qreal range = niceNumber(max-min,true); //range with ceiling
                 qreal step = niceNumber(range/(ticksCount-1),false);
                 min = qFloor(min/step);
                 max = qCeil(max/step);
                 ticksCount = int(max-min) +1;
                 min*=step;
                 max*=step;
             }
             //nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
             qreal QValueAxisPrivate::niceNumber(qreal x,bool ceiling) const
             {
                 qreal z = qPow(10,qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x/z;//q<10 && q>=1;
                 if(ceiling) {
                     if(q <= 1.0) q=1;
                     else if(q <= 2.0) q=2;
                     else if(q <= 5.0) q=5;
                     else q=10;
                 }
                 else {
                     if(q < 1.5) q=1;
                     else if(q < 3.0) q=2;
                     else if(q < 7.0) q=5;
                     else q=10;
                 }
                 return q*z;
             }
             #include "moc_qvalueaxis.cpp"
             #include "moc_qvalueaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.h +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$
             **
             ****************************************************************************/
             #ifndef QVALUESAXIS_H
             #define QVALUESAXIS_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QValueAxis : public QAbstractAxis
             {
                 Q_OBJECT
-                Q_PROPERTY(int ticksCount READ ticksCount WRITE setTicksCount)
+                Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount)
                 Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled)
                 Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
                 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
             public:
                 explicit QValueAxis(QObject *parent = 0);
                 ~QValueAxis();
             protected:
                 QValueAxis(QValueAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                 void setRange(qreal min, qreal max);
                 //ticks handling
-                void setTicksCount(int count);
+                void setTickCount(int count);
-                int ticksCount() const;
+                int tickCount() const;
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
             Q_SIGNALS:
                 void minChanged(qreal min);
                 void maxChanged(qreal max);
                 void rangeChanged(qreal min, qreal max);
             private:
                 Q_DECLARE_PRIVATE(QValueAxis)
                 Q_DISABLE_COPY(QValueAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUESAXIS_H

tests/auto/qvalueaxis/tst_qvalueaxis.cpp +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$
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include "qvalueaxis.h"
             #include <qlineseries.h>
             class tst_QValueAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qvalueaxis_data();
                 void qvalueaxis();
                 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 niceNumbersEnabled_data();
                 void niceNumbersEnabled();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void ticksCount_data();
                 void ticksCount();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
             private:
                 QValueAxis* m_valuesaxis;
                 QLineSeries* m_series;
             };
             void tst_QValueAxis::initTestCase()
             {
             }
             void tst_QValueAxis::cleanupTestCase()
             {
             }
             void tst_QValueAxis::init()
             {
                 m_valuesaxis = new QValueAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_valuesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QValueAxis::cleanup()
             {
                 delete m_series;
                 delete m_valuesaxis;
                 m_series = 0;
                 m_valuesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QValueAxis::qvalueaxis_data()
             {
             }
             void tst_QValueAxis::qvalueaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
-                QCOMPARE(m_valuesaxis->ticksCount(), 5);
+                QCOMPARE(m_valuesaxis->tickCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValues);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
-                QCOMPARE(m_valuesaxis->ticksCount(), 5);
+                QCOMPARE(m_valuesaxis->tickCount(), 5);
             }
             void tst_QValueAxis::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_QValueAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMax(max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QValueAxis::max()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QValueAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QValueAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QValueAxis::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_QValueAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMin(min);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QValueAxis::min()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QValueAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QValueAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QValueAxis::niceNumbersEnabled_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("ticks");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<int>("expectedTicks");
                 QTest::newRow("true 0.1 , 99.0 , 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 1 , 10.0 , 5") << true << 1.0 << 10.0 << 5 << 0.0 << 10.0 << 6;
                 QTest::newRow("true 0.1 , 6.6 , 5") << true << 0.1 << 6.6 << 5 << 0.0 << 8.0 << 5;
                 QTest::newRow("false 0.1 , 6.6 , 5") << false << 0.1 << 6.6 << 5 << 0.1 << 6.6 << 5;
                 QTest::newRow("true 0.1, 99, 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 5, 93.5 , 5") << true << 5.0 << 93.5 << 5 << 0.0 << 100.0 << 6;
             }
             void tst_QValueAxis::niceNumbersEnabled()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, ticks);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(int, expectedTicks);
                 m_valuesaxis->setRange(min, max);
-                m_valuesaxis->setTicksCount(ticks);
+                m_valuesaxis->setTickCount(ticks);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
                 if(!qFuzzyIsNull(expectedMin - min))
                     QCOMPARE(spy1.count(), 1);
                 if(!qFuzzyIsNull(expectedMax - max))
                     QCOMPARE(spy0.count(), 1);
                 if((!qFuzzyIsNull(expectedMin - min)) || (!qFuzzyIsNull(expectedMax - max)))
                     QCOMPARE(spy2.count(), 1);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - expectedMin), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - expectedMax), "Max not equal");
-                QCOMPARE(m_valuesaxis->ticksCount(), expectedTicks);
+                QCOMPARE(m_valuesaxis->tickCount(), expectedTicks);
             }
             void tst_QValueAxis::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_QValueAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QValueAxis::range()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QValueAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QValueAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QValueAxis::ticksCount_data()
             {
                 QTest::addColumn<int>("ticksCount");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("0") << 2;
                 QTest::newRow("1") << 2;
                 QTest::newRow("2") << 2;
                 QTest::newRow("3") << 3;
                 QTest::newRow("-1") << 2;
             }
             void tst_QValueAxis::ticksCount()
             {
                 QFETCH(int, ticksCount);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
-                m_valuesaxis->setTicksCount(ticksCount);
+                m_valuesaxis->setTickCount(ticksCount);
-                QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
+                QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
+                QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
             }
             void tst_QValueAxis::noautoscale_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_QValueAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
             }
             void tst_QValueAxis::autoscale_data()
             {
             }
             void tst_QValueAxis::autoscale()
             {
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min()), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max()), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() + 100), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - 100), "Max not equal");
             }
             QTEST_MAIN(tst_QValueAxis)
             #include "tst_qvalueaxis.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