HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1812:329e3a076da0

Docs update after classes renaming

Marek Rosa -

r1812:329e3a076da0

parent child

Context file:

r1812:329e3a076da0

Collapse all files

doc/src/classes.qdoc +2 -2

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

src/axis/datetimeaxis/qdatetimeaxis.cpp +5 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qdatetimeaxis.h"
             #include "qdatetimeaxis_p.h"
             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
             #include "domain_p.h"
             #include <cmath>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QDateTimeAxis
                 \brief The QDateTimeAxis class is used for manipulating chart's axis.
                 \mainclass
                 The labels can be configured by setting an appropriate DateTime format.
                 Note that any date before 4800 BCE or after about 1.4 million CE may not be accurately stored.
                 QDateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass DateTimeAxis QDateTimeAxis
                 \brief The DateTimeAxis element is used for manipulating chart's axes
                 The labels can be configured by setting an appropriate DateTime format.
                 Note that any date before 4800 BCE or after about 1.4 million CE may not be accurately stored.
                 DateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
               \property QDateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QDateTimeAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QDateTimeAxis::minChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::maxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::rangeChanged(QDateTime min, QDateTime max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
-              \property QDateTimeAxis::ticksCount
+              \property QDateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
-              \qmlproperty int ValuesAxis::ticksCount
+              \qmlproperty int ValuesAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QDateTimeAxis::QDateTimeAxis(QObject *parent) :
                 QAbstractAxis(*new QDateTimeAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QDateTimeAxis::QDateTimeAxis(QDateTimeAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QDateTimeAxis::~QDateTimeAxis()
             {
             }
             void QDateTimeAxis::setMin(QDateTime min)
             {
                 Q_D(QDateTimeAxis);
                 if (min.isValid())
                     setRange(min, qMax(d->m_max, min));
             }
             QDateTime QDateTimeAxis::min() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_min;
             }
             void QDateTimeAxis::setMax(QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (max.isValid())
                     setRange(qMin(d->m_min, max), max);
             }
             QDateTime QDateTimeAxis::max() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QDateTimeAxis::setRange(QDateTime min, QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (!min.isValid() || !max.isValid() || min > max)
                     return;
                 bool changed = false;
                 if (d->m_min != min) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (d->m_max != max) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 //        if(d->m_niceNumbers) d->looseNiceNumbers(d->m_min, d->m_max, d->m_tickCount);
                 if (changed) {
                     emit rangeChanged(d->m_min,d->m_max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a format string that is used when creating label for the axis out of the QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
-              \sa formatString()
+              \sa format()
             */
             void QDateTimeAxis::setFormat(QString format)
             {
                 Q_D(QDateTimeAxis);
                 d->m_format = format;
             }
             /*!
               Returns the format string that is used when creating label for the axis out of the QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
-              \sa setFormatString()
+              \sa setFormat()
             */
             QString QDateTimeAxis::format() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_format;
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QDateTimeAxis::setTickCount(int count)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
-              \fn int QDateTimeAxis::ticksCount() const
+              \fn int QDateTimeAxis::tickCount() const
               Return number of ticks on the axis
             */
             int QDateTimeAxis::tickCount() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_tickCount;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QDateTimeAxis::type() const
             {
                 return AxisTypeDateTime;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis* q):
                 QAbstractAxisPrivate(q),
                 m_tickCount(5)
             {
                 m_min = QDateTime::fromMSecsSinceEpoch(0);
                 m_max = QDateTime::fromMSecsSinceEpoch(0);
                 m_format = "dd-MMM-yy\nh:mm";
             }
             QDateTimeAxisPrivate::~QDateTimeAxisPrivate()
             {
             }
             void QDateTimeAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QDateTimeAxis);
                 Domain* domain = qobject_cast<Domain*>(sender());
                 Q_ASSERT(domain);
                 if(orientation()==Qt::Horizontal){
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
                 }else if(orientation()==Qt::Vertical){
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
                 }
             }
             void QDateTimeAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime))
                     q->setMin(min.toDateTime());
             }
             void QDateTimeAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (max.canConvert(QVariant::DateTime))
                     q->setMax(max.toDateTime());
             }
             void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime) && max.canConvert(QVariant::DateTime))
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
             ChartAxis* QDateTimeAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QDateTimeAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartDateTimeAxisY(q,presenter);
                 }else{
                     return new ChartDateTimeAxisX(q,presenter);
                 }
             }
             void QDateTimeAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QDateTimeAxis);
                 if(m_max == m_min) {
                     if(m_orientation==Qt::Vertical){
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
                     }else{
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
                     }
                 } else {
                     if(m_orientation==Qt::Vertical){
                         domain->setRangeY(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
                     }else{
                         domain->setRangeX(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
                     }
                 }
             }
             #include "moc_qdatetimeaxis.cpp"
             #include "moc_qdatetimeaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.cpp +12 -12

             /****************************************************************************
             **
             ** 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.
+                ValueAxis 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
+                \qmlclass ValueAxis QValueAxis
-                \brief The ValuesAxis element is used for manipulating chart's axes
+                \brief The ValueAxis 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 {
+                        ValueAxis {
                             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
+              \qmlproperty real ValueAxis::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
+              \qmlproperty real ValueAxis::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)
+              \qmlsignal ValueAxis::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)
+              \qmlsignal ValueAxis::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
+              \property QValueAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
-              \qmlproperty int ValuesAxis::ticksCount
+              \qmlproperty int ValueAxis::tickCount
               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
+              \qmlproperty bool ValueAxis::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) 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::setTickCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
-              \fn int QValueAxis::ticksCount() const
+              \fn int QValueAxis::tickCount() const
               Return number of ticks on the axis
             */
             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

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