HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2268:2fcc3c0fd3b6

setLabelFormat bug fixed in QValueAxis

Marek Rosa -

r2268:2fcc3c0fd3b6

parent child

Context file:

r2268:2fcc3c0fd3b6

Collapse all files

src/axis/chartaxis.cpp +11 -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 "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartElement(presenter),
                   m_chartAxis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                   m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                   m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                   m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                   m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
                   m_min(0),
                   m_max(0),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(), SIGNAL(updated()), this, SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->childItems().size() == 0)
                     m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++)
                         m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                 }
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
                     label->setFont(m_font);
                     m_labels->addToGroup(label);
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
                         m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (diff < 0) handleAxisUpdated();
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 if (m_font != font) {
                     m_font = font;
                     foreach (QGraphicsItem *item , m_labels->childItems())
                         static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyCompare(m_min, m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain *domain = qobject_cast<Domain *>(sender());
                 qreal min(0);
                 qreal max(0);
                 if (m_chartAxis->orientation() == Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 } else if (m_chartAxis->orientation() == Qt::Vertical) {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyCompare(m_min, min) || !qFuzzyCompare(m_max, max)) {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                         QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                         QSizeF after = sizeHint(Qt::PreferredSize);
                         if (before != after) {
                             QGraphicsLayoutItem::updateGeometry();
                             //we don't want to call invalidate on layout, since it will change minimum size of component,
                             //which we would like to avoid since it causes nasty flips when scrolling or zooming,
                             //instead recalculate layout and use plotArea for extra space.
                             presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                         }
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty())
                     return;
                 bool visible = m_chartAxis->isVisible();
                 //TODO: split this into separate signal/slots ?
                 setArrowVisibility(visible && m_chartAxis->isLineVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->linePen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
                 setTitleText(m_chartAxis->title());
                 setTitleFont(m_chartAxis->titleFont());
                 setTitlePen(m_chartAxis->titlePen());
                 setTitleBrush(m_chartAxis->titleBrush());
             }
             void ChartAxis::setTitleText(const QString &title)
             {
                 if (m_titleText != title) {
                     m_titleText = title;
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setTitlePen(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::setTitleBrush(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::setTitleFont(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             QFont ChartAxis::titleFont() const
             {
                 return  m_title->font();
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::axisSelected()
             {
                 //TODO: axis clicked;
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_chartAxis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_chartAxis->alignment();
             }
             bool ChartAxis::isVisible()
             {
                 return m_chartAxis->isVisible();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QStringList ChartAxis::createValueLabels(int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-qFloor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 QString format = axis->labelFormat();
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
-                        labels << QString().sprintf(array, value);
+                        if (format.contains("d")
+                                || format.contains("i")
+                                || format.contains("c"))
+                            labels << QString().sprintf(array, (qint64)value);
+                        else if (format.contains("u")
+                                 || format.contains("o")
+                                 || format.contains("x", Qt::CaseInsensitive))
+                            labels << QString().sprintf(array, (quint64)value);
+                        else
+                            labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(const QString &format, int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-floor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.cpp +4 -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 "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
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks.
                 Example code on how to use QValueAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QLineSeries *series = new QLineSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 QValueAxis *axisX = new QValueAxis;
                 axisX->setRange(10, 20.5);
                 axisX->setTickCount(10);
                 axisX->setLabelFormat("%.2f");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass ValueAxis QValueAxis
                 \inherits AbstractAxis
                 \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 {
                         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 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 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.
             */
             /*!
               \property QValueAxis::labelFormat
               Defines the label format for the axis.
-              See QString::sprintf() for the details.
+              Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
+              See QString::sprintf() for additional details.
             */
             /*!
               \qmlproperty real ValueAxis::labelFormat
               Defines the label format for the axis.
-              See QString::sprintf() for the details.
+              Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
+              See QString::sprintf() for additional details.
             */
             /*!
               \fn void QValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \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 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::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \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 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 (!qFuzzyCompare(d->m_min, min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyCompare(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::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 && !qFuzzyCompare(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;
             }
             void QValueAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QValueAxis);
                 d->m_format = format;
             }
             QString QValueAxis::labelFormat() const
             {
                 Q_D(const QValueAxis);
                 return d->m_format;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValueAxis::type() const
             {
                 return AxisTypeValue;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5),
                   m_niceNumbers(false),
                   m_format(QString::null)
             {
             }
             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);
                 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