HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2709:682630e62d58

Additional fixes to label localization...

Miikka Heikkinen -

r2709:682630e62d58

parent child

Context file:

r2709:682630e62d58

Collapse all files

src/axis/chartaxiselement.cpp +7 -5

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "chartaxiselement_p.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             static const char *labelFormatMatchString = "%[\\-\\+#\\s\\d\\.lhjztL]*([dicuoxfegXFEG])";
-            static const char *labelFormatMatchLocalizedString = "^([^%]*)%\\.?(\\d)*([defgEG])(.*)$";
+            static const char *labelFormatMatchLocalizedString = "^([^%]*)%\\.?(\\d)*([defgiEG])(.*)$";
             static QRegExp *labelFormatMatcher = 0;
             static QRegExp *labelFormatMatcherLocalized = 0;
             class StaticLabelFormatMatcherDeleter
             {
             public:
                 StaticLabelFormatMatcherDeleter() {}
                 ~StaticLabelFormatMatcherDeleter() {
                     delete labelFormatMatcher;
                     delete labelFormatMatcherLocalized;
                 }
             };
             static StaticLabelFormatMatcherDeleter staticLabelFormatMatcherDeleter;
             ChartAxisElement::ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_animation(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsTextItem(item)),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 m_title->document()->setDocumentMargin(ChartPresenter::textMargin());
                 handleVisibleChanged(axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents, true);
             }
             ChartAxisElement::~ChartAxisElement()
             {
             }
             void ChartAxisElement::connectSlots()
             {
                 QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsPenChanged(const QPen&)), this, SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(titlePenChanged(const QPen&)), this, SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
             }
             void ChartAxisElement::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxisElement::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_labels->setVisible(visible);
             }
             void ChartAxisElement::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxisElement::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsPenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 if (title.isEmpty() || !m_title->isVisible())
                     m_title->setHtml(title);
             }
             void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleTitleFontChanged(const QFont &font)
             {
                 if (m_title->font() != font) {
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxisElement::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if (!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 } else {
                     m_grid->setVisible(axis()->isGridLineVisible());
                     m_arrow->setVisible(axis()->isLineVisible());
                     m_shades->setVisible(axis()->shadesVisible());
                     m_labels->setVisible(axis()->labelsVisible());
                     m_title->setVisible(axis()->isTitleVisible());
                 }
                 if (presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(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());
                     }
                 }
             }
             bool ChartAxisElement::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             qreal ChartAxisElement::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxisElement::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QString ChartAxisElement::formatLabel(const QString &formatSpec, const QByteArray &array,
                                                   qreal value, int precision, const QString &preStr,
                                                   const QString &postStr) const
             {
                 QString retVal;
                 if (!formatSpec.isEmpty()) {
                     if (formatSpec.at(0) == QLatin1Char('d')
                         || formatSpec.at(0) == QLatin1Char('i')
                         || formatSpec.at(0) == QLatin1Char('c')) {
                         if (presenter()->localizeNumbers())
                             retVal = preStr + presenter()->locale().toString(qint64(value)) + postStr;
                         else
                             retVal = QString().sprintf(array, qint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('u')
                              || formatSpec.at(0) == QLatin1Char('o')
                              || formatSpec.at(0) == QLatin1Char('x')
                              || formatSpec.at(0) == QLatin1Char('X')) {
                         // These formats are not supported by localized numbers
                         retVal = QString().sprintf(array, quint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('f')
                                || formatSpec.at(0) == QLatin1Char('F')
                                || formatSpec.at(0) == QLatin1Char('e')
                                || formatSpec.at(0) == QLatin1Char('E')
                                || formatSpec.at(0) == QLatin1Char('g')
                                || formatSpec.at(0) == QLatin1Char('G')) {
                         if (presenter()->localizeNumbers()) {
                             retVal = preStr
                                     + presenter()->locale().toString(value, formatSpec.at(0).toLatin1(),
                                                                      precision)
                                     + postStr;
                         } else {
                             retVal = QString().sprintf(array, value);
                         }
                     }
                 }
                 return retVal;
             }
             QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks,
                                                             const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 if (format.isNull()) {
                     int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0) + 1;
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
-                    int precision = 0;
+                    int precision = 6; // Six is the default precision in Qt API
                     if (presenter()->localizeNumbers()) {
                         if (!labelFormatMatcherLocalized)
                             labelFormatMatcherLocalized = new QRegExp(labelFormatMatchLocalizedString);
                         if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
                             preStr = labelFormatMatcherLocalized->cap(1);
-                            precision = labelFormatMatcherLocalized->cap(2).toInt();
+                            if (!labelFormatMatcherLocalized->cap(2).isEmpty())
+                                precision = labelFormatMatcherLocalized->cap(2).toInt();
                             formatSpec = labelFormatMatcherLocalized->cap(3);
                             postStr = labelFormatMatcherLocalized->cap(4);
                         }
                     } else {
                         if (!labelFormatMatcher)
                             labelFormatMatcher = new QRegExp(labelFormatMatchString);
                         if (labelFormatMatcher->indexIn(format, 0) != -1)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     int n = 0;
                     if (ticks > 1)
                         n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                     n++;
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
-                    int precision = 0;
+                    int precision = 6; // Six is the default precision in Qt API
                     if (presenter()->localizeNumbers()) {
                         if (!labelFormatMatcherLocalized)
                             labelFormatMatcherLocalized = new QRegExp(labelFormatMatchLocalizedString);
                         if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
                             preStr = labelFormatMatcherLocalized->cap(1);
-                            precision = labelFormatMatcherLocalized->cap(2).toInt();
+                            if (!labelFormatMatcherLocalized->cap(2).isEmpty())
+                                precision = labelFormatMatcherLocalized->cap(2).toInt();
                             formatSpec = labelFormatMatcherLocalized->cap(3);
                             postStr = labelFormatMatcherLocalized->cap(4);
                         }
                     } else {
                         if (!labelFormatMatcher)
                             labelFormatMatcher = new QRegExp(labelFormatMatchString);
                         if (labelFormatMatcher->indexIn(format, 0) != -1)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << presenter()->locale().toString(QDateTime::fromMSecsSinceEpoch(value), format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "abstractdomain_p.h"
             #include "polarchartvalueaxisangular_p.h"
             #include "polarchartvalueaxisradial_p.h"
             #include "chartdataset_p.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValueAxis
                 \inmodule Qt Charts
                 \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
             */
             #ifdef QDOC_QT5
             /*!
                 \qmltype ValueAxis
                 \instantiates QValueAxis
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/valueaxis.qdocinc
             */
             #else
             /*!
                 \qmlclass ValueAxis QValueAxis
                 \include ../doc/src/valueaxis.qdocinc
             */
             #endif
             /*!
               \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::tickCount
               Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
               The default value is 5, and it can not be below 2.
             */
             /*!
               \qmlproperty real ValueAxis::tickCount
                Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
                The default value is 5, and it can not be below 2.
             */
             /*!
               \property QValueAxis::labelFormat
               Defines the label format of the axis.
               Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, and c.
               See QString::sprintf() for additional details.
               If the QChart::localizeNumbers is \c{true}, the supported specifiers are limited to: d, e, E, f,
-              g, and G. Also, only the precision modifier is supported. The rest of the formatting comes from
+              g, G, and i. Also, only the precision modifier is supported. The rest of the formatting comes from
               the default QLocale of the application.
             */
             /*!
               \qmlproperty real ValueAxis::labelFormat
               Defines the label format of the axis.
               Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, and c.
               See QString::sprintf() for additional details.
               If the ChartView::localizeNumbers is \c{true}, the supported specifiers are limited to: d, e, E, f,
-              g, and G. Also, only the precision modifier is supported. The rest of the formatting comes from
+              g, G, and i. Also, only the precision modifier is supported. The rest of the formatting comes from
               the default QLocale of the application.
             */
             /*!
               \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::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount 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.
             */
             /*!
               \fn void QValueAxis::labelFormatChanged(const QString &format)
               Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \qmlsignal ValueAxis::labelFormatChanged(const QString &format)
               Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \property QValueAxis::niceNumbersEnabled
               \obsolete
               Using this function can lead to unexpected behavior. Use applyNiceNumbers() instead.
             */
             /*!
               \qmlproperty bool ValueAxis::niceNumbersEnabled
               Deprecated; Using this function can lead to unexpected behavior. Use applyNiceNumbers() instead.
             */
             /*!
                 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_chart)
                     d->m_chart->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);
                 d->setRange(min,max);
             }
             void QValueAxis::setTickCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                     emit tickCountChanged(count);
                 }
             }
             int QValueAxis::tickCount() const
             {
                 Q_D(const QValueAxis);
                 return d->m_tickCount;
             }
             void QValueAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValueAxis);
                 qWarning() << "Deprecated; Using this function can lead to unexpected behavior. " \
                               "Use applyNiceNumbers() instead.";
                 if(enable) {
                     QObject::connect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
                     QObject::connect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
                     applyNiceNumbers();
                 }
                 else {
                     QObject::disconnect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
                     QObject::disconnect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
                 }
                 d->m_niceNumbersEnabled=enable;
             }
             bool QValueAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValueAxis);
                 qWarning() << "Deprecated; Using this function can lead to unexpected behavior. " \
                               "Use applyNiceNumbers() instead.";
                 return d->m_niceNumbersEnabled;
             }
             void QValueAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QValueAxis);
                 d->m_format = format;
                 emit labelFormatChanged(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;
             }
             /*!
                 This method modifies range and number of ticks on the axis to look "nice". Algorithm considers numbers that
                 can be expressed as form of 1*10^n, 2* 10^n or 5*10^n as a nice numbers. These numbers are used for spacing the ticks.
                 This method will modify the current range and number of ticks.
                 \sa setRange(), setTickCount()
             */
             void QValueAxis::applyNiceNumbers()
             {
                 Q_D(QValueAxis);
                 if(d->m_applying) return;
                 qreal min = d->m_min;
                 qreal max = d->m_max;
                 int ticks = d->m_tickCount;
                 AbstractDomain::looseNiceNumbers(min,max,ticks);
                 d->m_applying=true;
                 d->setRange(min,max);
                 setTickCount(ticks);
                 d->m_applying=false;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5),
                   m_format(QString::null),
                   m_applying(false),
                   m_niceNumbersEnabled(false)
             {
             }
             QValueAxisPrivate::~QValueAxisPrivate()
             {
             }
             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);
             }
             void QValueAxisPrivate::setRange(qreal min, qreal max)
             {
             	Q_Q(QValueAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 bool changeMin = false;
                 if (m_min == 0 || min == 0)
                     changeMin = !qFuzzyCompare(1 + m_min, 1 + min);
                 else
                     changeMin = !qFuzzyCompare(m_min, min);
                 bool changeMax = false;
                 if (m_max == 0 || max == 0)
                     changeMax = !qFuzzyCompare(1 + m_max, 1 + max);
                 else
                     changeMax = !qFuzzyCompare(m_max, max);
                 if (changeMin) {
                 	m_min = min;
                     changed = true;
                     emit q->minChanged(min);
                 }
                 if (changeMax) {
                     m_max = max;
                     changed = true;
                     emit q->maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(min,max);
                     emit q->rangeChanged(min, max);
                 }
             }
             void QValueAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QValueAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartValueAxisY(q,parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new ChartValueAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartValueAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartValueAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QValueAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (orientation() == Qt::Vertical) {
                     if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeY(m_min, m_max);
                     else
                         setRange(domain->minY(), domain->maxY());
                 }
                 if (orientation() == Qt::Horizontal) {
                     if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeX(m_min, m_max);
                     else
                         setRange(domain->minX(), domain->maxX());
                 }
             }
             #include "moc_qvalueaxis.cpp"
             #include "moc_qvalueaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "abstractdomain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qbarlegendmarker.h"
             #include "baranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
                 \inmodule Qt Charts
                 \brief Series for creating a bar chart.
                 \mainclass
                 QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             #ifdef QDOC_QT5
             /*!
                 \qmltype AbstractBarSeries
                 \instantiates QAbstractBarSeries
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/abstractbarseries.qdocinc
             */
             #else
             /*!
                 \qmlclass AbstractBarSeries QAbstractBarSeries
                 \include ../doc/src/abstractbarseries.qdocinc
             */
             #endif
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a BarCategoriesAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \property QAbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QBarSeries
             */
             /*!
                 \qmlproperty real AbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int AbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool AbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \property QAbstractBarSeries::labelsFormat
                 The \a format used for showing labels in series.
                 QAbstractBarSeries supports the following format tag:
                 \table
                   \row
                     \li @value      \li The value of the bar
                 \endtable
                 For example, the following usage of the format tags would produce labels that show the value
                 followed by unit ('u'):
                 \code
                 series->setLabelsFormat("@value u");
                 \endcode
                 By default, the labels shows the value of the bar. For percent bar series '%' is added after
                 the value. The labels are shown on the plot area, labels on the edge of the plot area are cut.
                 If the bars are close to each other the labels may overlap.
                 \sa QAbstractBarSeries::labelsVisible, QAbstractBarSeries::labelsPosition
             */
             /*!
                 \qmlproperty string AbstractBarSeries::labelsFormat
                 The format used for showing labels in series.
                 \sa QAbstractBarSeries::labelsFormat, labelsVisible, labelsPosition
             */
             /*!
                 \fn void QAbstractBarSeries::labelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data value labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data value labels is changed.
             */
             /*!
              \enum QAbstractBarSeries::LabelsPosition
              This enum describes the position of the data value labels.
              \value LabelsCenter Label is in the center of the bar.
              \value LabelsInsideEnd Label is inside the bar at the high end of it.
              \value LabelsInsideBase Label is inside the bar at the low end of it.
              \value LabelsOutsideEnd Label is outside the bar at the high end of it.
              */
             /*!
                 \property QAbstractBarSeries::labelsPosition
                 Defines the \a position of value labels.
                 \sa QAbstractBarSeries::labelsVisible, QAbstractBarSeries::labelsFormat
             */
             /*!
                 \qmlproperty string AbstractBarSeries::labelsPosition
                 Defines the \a position of value labels.
                 \sa labelsVisible, labelsFormat
             */
             /*!
                 \fn void QAbstractBarSeries::labelsPositionChanged(QAbstractBarSeries::LabelsPosition position)
                 Signal is emitted when the \a position of value labels is changed.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onLabelsPositionChanged(LabelsPosition position)
                 Signal is emitted when the \a position of value labels is changed.
             */
             /*!
                 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QAbstractBarSeries::hovered(bool status, int index, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
                 Hovered bar inside the set is indexed by \a index.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onHovered(bool status, int index, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
                 Hovered bar inside the set is indexed by \a index.
             */
             /*!
                 \fn void QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values is a list of reals.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa AbstractBarSeries::append()
             */
             /*!
                 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successful, false otherwise.
             */
             /*!
                 \qmlmethod AbstractBarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
                 : QAbstractSeries(o, parent)
             {
                 Q_D(QAbstractSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the barset object.
                 NOTE: The series remains as the barset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QAbstractBarSeries::take(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QAbstractBarSeries::append(QList<QBarSet *> sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all barsets from the series. Deletes removed sets.
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBarSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet *> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             void QAbstractBarSeries::setLabelsFormat(const QString &format)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsFormat != format) {
                     d->m_labelsFormat = format;
                     emit labelsFormatChanged(format);
                 }
             }
             QString QAbstractBarSeries::labelsFormat() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsFormat;
             }
             void QAbstractBarSeries::setLabelsPosition(QAbstractBarSeries::LabelsPosition position)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsPosition != position) {
                     d->m_labelsPosition = position;
                     emit labelsPositionChanged(position);
                 }
             }
             QAbstractBarSeries::LabelsPosition QAbstractBarSeries::labelsPosition() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsPosition;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true),
                 m_blockBarUpdate(false),
                 m_labelsFormat(),
                 m_labelsPosition(QAbstractBarSeries::LabelsCenter)
             {
             }
             int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count)
                         count = m_barSets.at(i)->count();
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0)
                     width = 0.0;
                 m_barWidth = width;
                 emit updatedLayout();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit visibleChanged();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if (qFuzzyCompare(sum, 0))
                     return 0;
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::categoryTop(int category)
             {
                 // Returns top (sum of all positive values) of category.
                 // Returns 0, if all values are negative
                 qreal top(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp > 0) {
                             top += temp;
                         }
                     }
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
             {
                 // Returns bottom (sum of all negative values) of category
                 // Returns 0, if all values are positive
                 qreal bottom(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp < 0) {
                             bottom += temp;
                         }
                     }
                 }
                 return bottom;
             }
             qreal QAbstractBarSeriesPrivate::top()
             {
                 // Returns top of all categories
                 qreal top(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryTop(i);
                     if (temp > top)
                         top = temp;
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::bottom()
             {
                 // Returns bottom of all categories
                 qreal bottom(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryBottom(i);
                     if (temp < bottom)
                         bottom = temp;
                 }
                 return bottom;
             }
             bool QAbstractBarSeriesPrivate::blockBarUpdate()
             {
                 return m_blockBarUpdate;
             }
             void QAbstractBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     QBarLegendMarker* marker = new QBarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 if (!m_barSets.contains(set))
                     return false; // Fail if set is not in list
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
             {
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             void QAbstractBarSeriesPrivate::initializeAxes()
             {
                 Q_Q(QAbstractBarSeries);
                 foreach(QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         switch (q->type()) {
                         case QAbstractSeries::SeriesTypeHorizontalBar:
                         case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                         case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                             if (axis->orientation() == Qt::Vertical)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                         case QAbstractSeries::SeriesTypeBar:
                         case QAbstractSeries::SeriesTypePercentBar:
                         case QAbstractSeries::SeriesTypeStackedBar:
                         case QAbstractSeries::SeriesTypeBoxPlot:
                             if (axis->orientation() == Qt::Horizontal)
                                 populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                         default:
                             qWarning() << "Unexpected series type";
                         break;
                         }
                     }
                 }
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_Q(const QAbstractBarSeries);
                 switch (q->type()) {
                 case QAbstractSeries::SeriesTypeHorizontalBar:
                 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                 case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                     if (orientation == Qt::Vertical)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 case QAbstractSeries::SeriesTypeBar:
                 case QAbstractSeries::SeriesTypePercentBar:
                 case QAbstractSeries::SeriesTypeStackedBar:
                 case QAbstractSeries::SeriesTypeBoxPlot:
                     if (orientation == Qt::Horizontal)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 default:
                     qWarning() << "Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValue;
             }
             void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < categoryCount() + 1; i++)
-                        categories << QString::number(i);
+                        categories << presenter()->numberToString(i);
                     axis->append(categories);
                 }
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 if (defaultAxisType(orientation) == QAbstractAxis::AxisTypeBarCategory)
                     return new QBarCategoryAxis;
                 else
                     return new QValueAxis;
             }
             void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 m_blockBarUpdate = true; // Ensures that the bars are not updated before the theme is ready
                 const QList<QGradient> gradients = theme->seriesGradients();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (m_barSets.count() > 1) {
                     step = 1.0 / (qreal) m_barSets.count();
                     if (m_barSets.count() % gradients.count())
                     step *= gradients.count();
                     else
                     step *= (gradients.count() - 1);
                 }
                 for (int i(0); i < m_barSets.count(); i++) {
                     int colorIndex = (index + i) % gradients.count();
                     if (i > 0 && i %gradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                         takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_brush)
                         m_barSets.at(i)->setBrush(ChartThemeManager::colorAt(gradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_labelBrush) {
                         if (takeAtPos < 0.3)
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1));
                         else
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0));
                     }
                     if (forced || QChartPrivate::defaultPen() == m_barSets.at(i)->d_ptr->m_pen) {
                         QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                         m_barSets.at(i)->setPen(c);
                     }
                 }
                 m_blockBarUpdate = false;
                 emit updatedBars();
             }
             void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
                 Q_ASSERT(bar);
                 if (bar->animation())
                     bar->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new BarAnimation(bar));
                 else
                     bar->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/qboxplotseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "qboxplotseries.h"
             #include "qboxplotseries_p.h"
             #include "qboxplotlegendmarker.h"
             #include "qbarcategoryaxis.h"
             #include "boxplotchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "charttheme_p.h"
             #include "boxplotanimation_p.h"
             #include "qchart_p.h"
             #include "qboxset.h"
             #include "qboxset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBoxPlotSeries
                 \inmodule Qt Charts
                 \brief Series for creating box-and-whiskers chart
                 \mainclass
                 QBoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
                 a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple instances of
                 QBoxPlotSeries then box-and-whiskers items with the same index are drawn to same slot.
                 See the \l {Box and Whiskers Example} {box-and-whiskers chart example} to learn how to create a box-and-whiskers chart.
                 \image examples_boxplotchart.png
                 \sa QBoxSet
             */
             /*!
                 \fn QBoxPlotSeries::boxsetsAdded(QList<QBoxSet *> sets)
                 \brief Signal is emitted when a new \a sets of box-and-whiskers data is added to the series.
             */
             /*!
                 \fn QBoxPlotSeries::boxsetsRemoved(QList<QBoxSet *> sets)
                 \brief Signal is emitted when \a sets of box-and-whiskers data is removed from the series.
             */
             /*!
                 \fn QBoxPlotSeries::clicked(QBoxSet *boxset)
                 \brief Signal is emitted when the user clicks the \a boxset on the chart.
             */
             /*!
                 \fn QBoxPlotSeries::hovered(bool status, QBoxSet *boxset)
                 \brief Signal is emitted when there is change in hover \a status over \a boxset.
             */
             /*!
                 \fn QBoxPlotSeries::countChanged()
                 \brief Signal is emitted when there is change in count of box-and-whiskers items in the series.
             */
             /*!
                 \property QBoxPlotSeries::boxOutlineVisible
                 \brief This property configures the visibility of the middle box outline.
             */
             /*!
                 \property QBoxPlotSeries::boxWidth
                 \brief This property configures the width of the box-and-whiskers item. The value signifies the relative
                 width of the box-and-whiskers item inside its own slot. The value can between 0.0 and 1.0. Negative values
                 are clamped to 0.0 and values over 1.0 are clamped to 1.0.
             */
             /*!
                 \property QBoxPlotSeries::pen
                 \brief This property configures the pen of the box-and-whiskers items.
             */
             /*!
                 \property QBoxPlotSeries::brush
                 \brief This property configures the brush of the box-and-whiskers items.
             */
             /*!
                 \property QBoxPlotSeries::count
                 \brief The count of sets in series.
             */
             /*!
                 \qmlproperty QString BoxPlotSeries::brushFilename
                 The name of the file used as a brush for the series.
             */
             /*!
                 \fn void QBoxPlotSeries::boxOutlineVisibilityChanged()
                 Signal is emitted when the middle box outline visibility is changed.
             */
             /*!
                 \fn void QBoxPlotSeries::boxWidthChanged()
                 Signal is emitted when the width of the box-and-whiskers item is changed.
             */
             /*!
                 \fn void QBoxPlotSeries::penChanged()
                 This signal is emitted when the pen of the box-and-whiskers has changed.
                 \sa brush
             */
             /*!
                 \fn void QBoxPlotSeries::brushChanged()
                 This signal is emitted when the brush of the box-and-whiskers has changed.
                 \sa brush
             */
             /*!
                 \fn virtual SeriesType QBoxPlotSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             /*!
                 Constructs empty QBoxPlotSeries.
                 QBoxPlotSeries is QObject which is a child of a \a parent.
             */
             QBoxPlotSeries::QBoxPlotSeries(QObject *parent)
                 : QAbstractSeries(*new QBoxPlotSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QBoxPlotSeries::~QBoxPlotSeries()
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Adds a single box and whiskers set to series. Takes ownership of the \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBoxPlotSeries::append(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes boxset from the series. Deletes the \a set and returns true if successful.
             */
             bool QBoxPlotSeries::remove(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the boxset object.
                 NOTE: The series remains as the boxset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QBoxPlotSeries::take(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of boxsets to series. Takes ownership of the \a sets.
                 Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBoxPlotSeries::append(QList<QBoxSet *> sets)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a box-and-whiskers set to the series at \a index postion. Takes ownership of the \a set. If the set is null or
                 is already in series, it won't be appended. Returns true, if inserting succeeded.
             */
             bool QBoxPlotSeries::insert(int index, QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all boxsets from the series. Deletes removed sets.
             */
             void QBoxPlotSeries::clear()
             {
                 Q_D(QBoxPlotSeries);
                 QList<QBoxSet *> sets = boxSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBoxSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBoxPlotSeries::count() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_boxSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBoxSet *> QBoxPlotSeries::boxSets() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_boxSets;
             }
             /*
                 Returns QAbstractSeries::SeriesTypeBoxPlot.
             */
             QAbstractSeries::SeriesType QBoxPlotSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBoxPlot;
             }
             void QBoxPlotSeries::setBoxOutlineVisible(bool visible)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_boxOutlineVisible != visible) {
                     d->m_boxOutlineVisible = visible;
                     emit d->updated();
                     emit boxOutlineVisibilityChanged();
                 }
             }
             bool QBoxPlotSeries::boxOutlineVisible()
             {
                 Q_D(QBoxPlotSeries);
                 return d->m_boxOutlineVisible;
             }
             void QBoxPlotSeries::setBoxWidth(qreal width)
             {
                 Q_D(QBoxPlotSeries);
                 if (width != d->m_boxWidth) {
                     if (width < 0.0)
                         width = 0.0;
                     if (width > 1.0)
                         width = 1.0;
                     d->m_boxWidth = width;
                     emit d->updatedLayout();
                     emit boxWidthChanged();
                 }
             }
             qreal QBoxPlotSeries::boxWidth()
             {
                 Q_D(QBoxPlotSeries);
                 return d->m_boxWidth;
             }
             void QBoxPlotSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                     emit brushChanged();
                 }
             }
             QBrush QBoxPlotSeries::brush() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_brush;
             }
             void QBoxPlotSeries::setPen(const QPen &pen)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                     emit penChanged();
                 }
             }
             QPen QBoxPlotSeries::pen() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_pen;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxPlotSeriesPrivate::QBoxPlotSeriesPrivate(QBoxPlotSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_boxOutlineVisible(true),
                   m_boxWidth(0.5)
             {
             }
             QBoxPlotSeriesPrivate::~QBoxPlotSeriesPrivate()
             {
                 disconnect(this, 0, 0, 0);
             }
             void QBoxPlotSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = m_boxSets.count();
                 minX = qMin(minX, qreal(-0.5));
                 minY = qMin(minY, min());
                 maxX = qMax(maxX, x - qreal(0.5));
                 maxY = qMax(maxY, max());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QBoxPlotSeriesPrivate::initializeAxes()
             {
                 foreach (QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                     }
                 }
             }
             QAbstractAxis::AxisType QBoxPlotSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 if (orientation == Qt::Horizontal)
                     return QAbstractAxis::AxisTypeBarCategory;
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QBoxPlotSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 if (defaultAxisType(orientation) == QAbstractAxis::AxisTypeBarCategory)
                     return new QBarCategoryAxis;
                 else
                     return new QValueAxis;
             }
             void QBoxPlotSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < m_boxSets.count() + 1; i++) {
                         QBoxSet *set = m_boxSets.at(i - 1);
                         if (set->label().isEmpty())
-                            categories << QString::number(i);
+                            categories << presenter()->numberToString(i);
                         else
                             categories << set->label();
                     }
                     axis->append(categories);
                 }
             }
             void QBoxPlotSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QBoxPlotSeries);
                 BoxPlotChartItem *boxPlot = new BoxPlotChartItem(q, parent);
                 m_item.reset(boxPlot);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
                 if (m_chart) {
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesChange(QAbstractSeries*)) );
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SLOT(handleSeriesRemove(QAbstractSeries*)) );
                     QList<QAbstractSeries *> serieses = m_chart->series();
                     // Tries to find this series from the Chart's list of series and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
                         if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
                             if (q == static_cast<QBoxPlotSeries *>(s)) {
                                 boxPlot->m_seriesIndex = index;
                                 m_index = index;
                             }
                             index++;
                         }
                     }
                     boxPlot->m_seriesCount = index;
                 }
                 // Make BoxPlotChartItem to instantiate box & whisker items
                 boxPlot->handleDataStructureChanged();
             }
             void QBoxPlotSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QBoxPlotSeries);
                 const QList<QGradient> gradients = theme->seriesGradients();
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.5);
                     q->setBrush(brushColor);
                 }
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen = theme->outlinePen();
                     pen.setCosmetic(true);
                     q->setPen(pen);
                 }
             }
             void QBoxPlotSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 BoxPlotChartItem *item = static_cast<BoxPlotChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     m_animation = new BoxPlotAnimation(item);
                 else
                     m_animation = 0;
                 item->setAnimation(m_animation);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QBoxPlotSeriesPrivate::createLegendMarkers(QLegend *legend)
             {
                 Q_Q(QBoxPlotSeries);
                 QList<QLegendMarker *> list;
                 return list << new QBoxPlotLegendMarker(q, legend);
             }
             void QBoxPlotSeriesPrivate::handleSeriesRemove(QAbstractSeries *series)
             {
                 Q_Q(QBoxPlotSeries);
                 QBoxPlotSeries *removedSeries = static_cast<QBoxPlotSeries *>(series);
                 if (q == removedSeries && m_animation) {
                     m_animation->stopAll();
                     QObject::disconnect(m_chart->d_ptr->m_dataset, 0, removedSeries->d_func(), 0);
                 }
                 // Test if series removed is me, then don't do anything
                 if (q != removedSeries) {
                     BoxPlotChartItem *item = static_cast<BoxPlotChartItem *>(m_item.data());
                     if (item) {
                         item->m_seriesCount = item->m_seriesCount - 1;
                         if (removedSeries->d_func()->m_index < m_index) {
                             m_index--;
                             item->m_seriesIndex = m_index;
                         }
                         item->handleDataStructureChanged();
                     }
                 }
             }
             void QBoxPlotSeriesPrivate::handleSeriesChange(QAbstractSeries *series)
             {
                 Q_UNUSED(series);
                 Q_Q(QBoxPlotSeries);
                 BoxPlotChartItem *boxPlot = static_cast<BoxPlotChartItem *>(m_item.data());
                 if (m_chart) {
                     QList<QAbstractSeries *> serieses = m_chart->series();
                     // Tries to find this series from the Chart's list of series and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
                         if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
                             if (q == static_cast<QBoxPlotSeries *>(s)) {
                                 boxPlot->m_seriesIndex = index;
                                 m_index = index;
                             }
                             index++;
                         }
                     }
                     boxPlot->m_seriesCount = index;
                 }
                 boxPlot->handleDataStructureChanged();
             }
             bool QBoxPlotSeriesPrivate::append(QBoxSet *set)
             {
                 if (m_boxSets.contains(set) || (set == 0) || set->d_ptr->m_series)
                     return false; // Fail if set is already in list or set is null.
                 m_boxSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 set->d_ptr->m_series = this;
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::remove(QBoxSet *set)
             {
                 if (!m_boxSets.contains(set))
                     return false; // Fail if set is not in list
                 set->d_ptr->m_series = 0;
                 m_boxSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::append(QList<QBoxSet *> sets)
             {
                 foreach (QBoxSet *set, sets) {
                     if ((set == 0) || m_boxSets.contains(set) || set->d_ptr->m_series)
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBoxSet *set, sets) {
                     m_boxSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                     set->d_ptr->m_series = this;
                 }
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::remove(QList<QBoxSet *> sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBoxSet *set, sets) {
                     if ((set == 0) || (!m_boxSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBoxSet *set, sets) {
                     set->d_ptr->m_series = 0;
                     m_boxSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 }
                 emit restructuredBoxes();        // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::insert(int index, QBoxSet *set)
             {
                 if ((m_boxSets.contains(set)) || (set == 0) || set->d_ptr->m_series)
                     return false; // Fail if set is already in list or set is null.
                 m_boxSets.insert(index, set);
                 set->d_ptr->m_series = this;
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 emit restructuredBoxes();      // this notifies boxplotchartitem
                 return true;
             }
             QBoxSet *QBoxPlotSeriesPrivate::boxSetAt(int index)
             {
                 return m_boxSets.at(index);
             }
             qreal QBoxPlotSeriesPrivate::min()
             {
                 if (m_boxSets.count() <= 0)
                     return 0;
                 qreal min = m_boxSets.at(0)->at(0);
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < 5; i++) {
                         if (set->at(i) < min)
                             min = set->at(i);
                     }
                 }
                 return min;
             }
             qreal QBoxPlotSeriesPrivate::max()
             {
                 if (m_boxSets.count() <= 0)
                     return 0;
                 qreal max = m_boxSets.at(0)->at(0);
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < 5; i++) {
                         if (set->at(i) > max)
                             max = set->at(i);
                     }
                 }
                 return max;
             }
             #include "moc_qboxplotseries.cpp"
             #include "moc_qboxplotseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +8 0

             /****************************************************************************
              **
              ** Copyright (C) 2014 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 Enterprise Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Enterprise licenses may use this file in
              ** accordance with the Qt Enterprise 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "chartitem_p.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxiselement_p.h"
             #include "chartbackground_p.h"
             #include "cartesianchartlayout_p.h"
             #include "polarchartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
                   m_title(0),
                   m_localizeNumbers(true)
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options);
                 series->d_ptr->setPresenter(this);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     QChart::AnimationOptions oldOptions = m_options;
                     m_options = options;
                     if (options.testFlag(QChart::SeriesAnimations) != oldOptions.testFlag(QChart::SeriesAnimations)) {
                         foreach (QAbstractSeries *series, m_series)
                             series->d_ptr->initializeAnimations(m_options);
                     }
                     if (options.testFlag(QChart::GridAxisAnimations) != oldOptions.testFlag(QChart::GridAxisAnimations)) {
                         foreach (QAbstractAxis *axis, m_axes)
                             axis->d_ptr->initializeAnimations(m_options);
                     }
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
                     m_background->setBrush(QChartPrivate::defaultBrush());
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createPlotAreaBackgroundItem()
             {
                 if (!m_plotAreaBackground) {
                     if (m_chart->chartType() == QChart::ChartTypeCartesian)
                         m_plotAreaBackground = new QGraphicsRectItem(rootItem());
                     else
                         m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
                     // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
                     // antialising artifacts with axis lines for some reason.
                     m_plotAreaBackground->setPen(QPen(Qt::transparent));
                     m_plotAreaBackground->setBrush(Qt::NoBrush);
                     m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
                     m_plotAreaBackground->setVisible(false);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 animation->stop();
                 QTimer::singleShot(0, animation, SLOT(startChartAnimation()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setBackgroundRoundness(qreal diameter)
             {
                 createBackgroundItem();
                 m_background->setDiameter(diameter);
                 m_layout->invalidate();
             }
             qreal ChartPresenter::backgroundRoundness() const
             {
                 if (!m_background)
                     return 0;
                 return m_background->diameter();
             }
             void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::plotAreaBackgroundBrush() const
             {
                 if (!m_plotAreaBackground)
                     return QBrush();
                 return m_plotAreaBackground->brush();
             }
             void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::plotAreaBackgroundPen() const
             {
                 if (!m_plotAreaBackground)
                     return QPen();
                 return m_plotAreaBackground->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setDefaultTextColor(brush.color());
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return QBrush(m_title->defaultTextColor());
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setVisible(visible);
             }
             bool ChartPresenter::isPlotAreaBackgroundVisible() const
             {
                 if (!m_plotAreaBackground)
                     return false;
                 return m_plotAreaBackground->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             void ChartPresenter::setLocalizeNumbers(bool localize)
             {
                 m_localizeNumbers = localize;
                 m_layout->invalidate();
             }
             void ChartPresenter::setLocale(const QLocale &locale)
             {
                 m_locale = locale;
                 m_layout->invalidate();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
             {
                 return m_plotAreaBackground;
             }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             QRectF ChartPresenter::textBoundingRect(const QFont &font, const QString &text, qreal angle)
             {
                 static QGraphicsTextItem dummyTextItem;
                 static bool initMargin = true;
                 if (initMargin) {
                     dummyTextItem.document()->setDocumentMargin(textMargin());
                     initMargin = false;
                 }
                 dummyTextItem.setFont(font);
                 dummyTextItem.setHtml(text);
                 QRectF boundingRect = dummyTextItem.boundingRect();
                 // Take rotation into account
                 if (angle) {
                     QTransform transform;
                     transform.rotate(angle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             // boundingRect parameter returns the rotated bounding rect of the text
             QString ChartPresenter::truncatedText(const QFont &font, const QString &text, qreal angle,
                                                   qreal maxWidth, qreal maxHeight, QRectF &boundingRect)
             {
                 QString truncatedString(text);
                 boundingRect = textBoundingRect(font, truncatedString, angle);
                 if (boundingRect.width() > maxWidth || boundingRect.height() > maxHeight) {
                     // It can be assumed that almost any amount of string manipulation is faster
                     // than calculating one bounding rectangle, so first prepare a list of truncated strings
                     // to try.
                     static const char *truncateMatchString = "&#?[0-9a-zA-Z]*;$";
                     static QRegExp truncateMatcher(truncateMatchString);
                     QVector<QString> testStrings(text.length());
                     int count(0);
                     static QLatin1Char closeTag('>');
                     static QLatin1Char openTag('<');
                     static QLatin1Char semiColon(';');
                     static QLatin1String ellipsis("...");
                     while (truncatedString.length() > 1) {
                         int chopIndex(-1);
                         int chopCount(1);
                         QChar lastChar(truncatedString.at(truncatedString.length() - 1));
                         if (lastChar == closeTag)
                             chopIndex = truncatedString.lastIndexOf(openTag);
                         else if (lastChar == semiColon)
                             chopIndex = truncateMatcher.indexIn(truncatedString, 0);
                         if (chopIndex != -1)
                             chopCount = truncatedString.length() - chopIndex;
                         truncatedString.chop(chopCount);
                         testStrings[count] = truncatedString + ellipsis;
                         count++;
                     }
                     // Binary search for best fit
                     int minIndex(0);
                     int maxIndex(count - 1);
                     int bestIndex(count);
                     QRectF checkRect;
                     while (maxIndex >= minIndex) {
                         int mid = (maxIndex + minIndex) / 2;
                         checkRect = textBoundingRect(font, testStrings.at(mid), angle);
                         if (checkRect.width() > maxWidth || checkRect.height() > maxHeight) {
                             // Checked index too large, all under this are also too large
                             minIndex = mid + 1;
                         } else {
                             // Checked index fits, all over this also fit
                             maxIndex = mid - 1;
                             bestIndex = mid;
                             boundingRect = checkRect;
                         }
                     }
                     // Default to "..." if nothing fits
                     if (bestIndex == count) {
                         boundingRect = textBoundingRect(font, ellipsis, angle);
                         truncatedString = ellipsis;
                     } else {
                         truncatedString = testStrings.at(bestIndex);
                     }
                 }
                 return truncatedString;
             }
             QString ChartPresenter::numberToString(double value, char f, int prec)
             {
                 if (m_localizeNumbers)
                     return m_locale.toString(value, f, prec);
                 else
                     return QString::number(value, f, prec);
             }
+            QString ChartPresenter::numberToString(int value)
+            {
+                if (m_localizeNumbers)
+                    return m_locale.toString(value);
+                else
+                    return QString::number(value);
+            }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //because of QChart::ChartThemeId
             #include <QRectF>
             #include <QMargins>
             #include <QLocale>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setLocalizeNumbers(bool localize);
                 inline bool localizeNumbers() const { return m_localizeNumbers; }
                 void setLocale(const QLocale &locale);
                 inline const QLocale &locale() const { return m_locale; }
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle,
                                              qreal maxWidth, qreal maxHeight, QRectF &boundingRect);
                 inline static qreal textMargin() { return qreal(0.5); }
                 QString numberToString(double value, char f = 'g', int prec = 6);
+                QString numberToString(int value);
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
                 bool m_localizeNumbers;
                 QLocale m_locale;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

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