HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2707:ef2ab40bd1b9

Added QChart::localizeNumbers...

Miikka Heikkinen -

r2707:ef2ab40bd1b9

parent child

Context file:

r2707:ef2ab40bd1b9

Collapse all files

plugins/declarative/declarativechart.cpp +22 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 "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis.h"
             #include "qlogvalueaxis.h"
             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "declarativemargins.h"
             #include "chartdataset_p.h"
             #include "declarativeaxes.h"
             #include "qchart_p.h"
             #include "qpolarchart.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #ifdef CHARTS_FOR_QUICK2
             #include <QGraphicsSceneMouseEvent>
             #include <QGraphicsSceneHoverEvent>
             #include <QApplication>
             #include <QTimer>
             #include <QThread>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #ifdef QDOC_QT5
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/chartview.qdocinc
             */
             #else
             /*!
                 \qmlclass ChartView DeclarativeChart
                 \include ../doc/src/chartview.qdocinc
             */
             #endif
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animationOptions
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart.
               See the Qt documentation for more details of Font.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty color ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty real ChartView::backgroundRoundness
               The diameter of the rounding cirle at the corners of the chart background.
             */
             /*!
               \qmlproperty color ChartView::plotAreaColor
               The color of the background of the chart's plot area. By default plot area background uses chart's
               background color.
               \sa ChartView::backgroundColor
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty Margins ChartView::minimumMargins
               Deprecated; use margins instead.
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend. Please note that setting the
               properties of minimumMargins may be bigger than the defined value, depending on other ChartView
               properties that affect it's layout. If you need to know the actual plotting area used at any
               given time, you can check ChartView::plotArea instead.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::minimumMargins
             */
             /*!
               \qmlproperty Margins ChartView::margins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend.
             */
             /*!
+              \qmlproperty bool ChartView::localizeNumbers
+              \since QtCharts 2.0
+              When \c{true}, all generated numbers appearing in various series and axis labels will be
+              localized using the default QLocale of the application, which defaults to the system locale.
+              When \c{false}, the "C" locale is always used.
+              Defaults to \c{false}.
+            */
+            /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlsignal ChartView::onPlotAreaChanged(rect plotArea)
               The plot area of the chart has changed. This may happen for example, if you modify minimumMargins
               or if you resize the chart, or if you modify font size related properties of the legend or chart
               title.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QDECLARATIVE_ITEM *parent)
                 : QDECLARATIVE_PAINTED_ITEM(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QDECLARATIVE_ITEM *parent)
                 : QDECLARATIVE_PAINTED_ITEM(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
             #ifdef CHARTS_FOR_QUICK2
                 m_currentSceneImage = 0;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
                 connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>)));
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
             #else
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart(this);
                 else
                     m_chart = new QChart(this);
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             #endif
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*)));
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit minimumMarginsChanged();
                 emit plotAreaChanged(m_chart->plotArea());
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             #ifdef CHARTS_FOR_QUICK2
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = 0;
                 m_sceneImageLock.unlock();
             #endif
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Connect to axis changed signals (unless this is a pie series)
                         if (!qobject_cast<DeclarativePieSeries *>(series)) {
                             connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QDECLARATIVE_ITEM::componentComplete();
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Horizontal).contains(axis))
                         m_chart->setAxisX(axis, s);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Horizontal).contains(axis)) {
                         QList<QAbstractAxis *> oldAxes = m_chart->axes(Qt::Horizontal, s);
                         foreach (QAbstractAxis* a, oldAxes) {
                                 m_chart->removeAxis(a);
                                 delete a;
                         }
                         m_chart->addAxis(axis, Qt::AlignTop);
                     }
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Vertical).contains(axis))
                         m_chart->setAxisY(axis, s);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Vertical).contains(axis)) {
                         QList<QAbstractAxis *> oldAxes = m_chart->axes((Qt::Vertical), s);
                         foreach (QAbstractAxis* a, oldAxes) {
                             m_chart->removeAxis(a);
                             delete a;
                         }
                         m_chart->addAxis(axis, Qt::AlignRight);
                     }
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisYRight to null.";
                 }
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDECLARATIVE_ITEM::geometryChanged(newGeometry, oldGeometry);
                 // It would be better to trigger the plotAreaChanged signal from QChart::plotAreaChanged or
                 // similar. Since that kind of a signal is not clearly needed in the C++ API the work-around is
                 // to implement it here for the QML API purposes.
                 emit plotAreaChanged(m_chart->plotArea());
             }
             #ifdef CHARTS_FOR_QUICK2
             void DeclarativeChart::sceneChanged(QList<QRectF> region)
             {
                 Q_UNUSED(region);
                 if (m_guiThreadId == m_paintThreadId) {
                     // Rendering in gui thread, no need for shenannigans, just update
                     update();
                 } else {
                     // Multi-threaded rendering, need to ensure scene is actually rendered in gui thread
                     if (!m_updatePending) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
                         QTimer::singleShot(0, this, SLOT(renderScene()));
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32);
                 m_currentSceneImage->fill(Qt::transparent);
                 QPainter painter(m_currentSceneImage);
                 if (antialiasing())
                     painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
                 QRect renderRect(QPoint(0, 0), m_chart->size().toSize());
                 m_scene->render(&painter, renderRect, renderRect);
                 m_sceneImageLock.unlock();
                 update();
             }
             void DeclarativeChart::paint(QPainter *painter)
             {
                 if (!m_paintThreadId) {
                     m_paintThreadId = QThread::currentThreadId();
                     if (m_guiThreadId == m_paintThreadId) {
                         // No need for scene image in single threaded rendering, so delete
                         // the one that got made by default before the rendering type was
                         // detected.
                         delete m_currentSceneImage;
                         m_currentSceneImage = 0;
                     }
                 }
                 if (m_guiThreadId == m_paintThreadId) {
                     QRectF renderRect(QPointF(0, 0), m_chart->size());
                     m_scene->render(painter, renderRect, renderRect);
                 } else {
                     m_sceneImageLock.lock();
                     if (m_currentSceneImage) {
                         QRect imageRect(QPoint(0, 0), m_currentSceneImage->size());
                         QRect itemRect(QPoint(0, 0), QSize(width(), height()));
                         painter->drawImage(itemRect, *m_currentSceneImage, imageRect);
                     }
                     m_sceneImageLock.unlock();
                 }
             }
             void DeclarativeChart::mousePressEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 mouseEvent.setScreenPos(event->globalPos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(event->buttons());
                 mouseEvent.setButton(event->button());
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
                 m_mousePressButtons = event->buttons();
                 m_mousePressButton = Qt::NoButton;
             }
             void DeclarativeChart::hoverMoveEvent(QHoverEvent *event)
             {
                 // Convert hover move to mouse move, since we don't seem to get actual mouse move events.
                 // QGraphicsScene generates hover events from mouse move events, so we don't need
                 // to pass hover events there.
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 // Hover events do not have global pos in them, and the screen position doesn't seem to
                 // matter anyway in this use case, so just pass event pos instead of trying to
                 // calculate the real screen position.
                 mouseEvent.setScreenPos(event->pos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 m_lastMouseMoveScenePoint = mouseEvent.scenePos();
                 m_lastMouseMoveScreenPoint = mouseEvent.screenPos();
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             #endif
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCommercialChart::DeclarativeChart::setPlotAreaColor(QColor color)
             {
                 QBrush b = m_chart->plotAreaBackgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setPlotAreaBackgroundBrush(b);
                     m_chart->setPlotAreaBackgroundVisible(true);
                     emit plotAreaColorChanged();
                 }
             }
             QColor QtCommercialChart::DeclarativeChart::plotAreaColor()
             {
                 return m_chart->plotAreaBackgroundBrush().color();
             }
+            void DeclarativeChart::setLocalizeNumbers(bool localize)
+            {
+                if (m_chart->localizeNumbers() != localize) {
+                    m_chart->setLocalizeNumbers(localize);
+                    emit localizeNumbersChanged();
+                }
+            }
+            bool DeclarativeChart::localizeNumbers() const
+            {
+                return m_chart->localizeNumbers();
+            }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::backgroundRoundness() const
             {
                 return m_chart->backgroundRoundness();
             }
             void DeclarativeChart::setBackgroundRoundness(qreal diameter)
             {
                 if (m_chart->backgroundRoundness() != diameter) {
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             qreal DeclarativeChart::topMargin()
             {
                 qWarning() << "ChartView.topMargin is deprecated. Use margins instead.";
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 qWarning() << "ChartView.bottomMargin is deprecated. Use margins instead.";
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 qWarning() << "ChartView.leftMargin is deprecated. Use margins instead.";
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 qWarning() << "ChartView.rightMargin is deprecated. Use margins instead.";
                 return m_chart->margins().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QDECLARATIVE_LIST_PROPERTY<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
             #ifdef CHARTS_FOR_QUICK2
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             #else
                             &DeclarativeChart::axesAtFunc);
             #endif
             }
             void DeclarativeChart::axesAppendFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count();
                 }
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axesAtFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, int index)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]);
                     return axes.at(index);
                 }
                 return 0;
             }
             void DeclarativeChart::axesClearFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list)
             {
                 // Empty implementation
                 Q_UNUSED(list);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach (QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea: {
                     DeclarativeAreaSeries *area = new DeclarativeAreaSeries();
                     area->setUpperSeries(new DeclarativeLineSeries());
                     series = area;
                     break;
                 }
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBoxPlot:
                     series = new DeclarativeBoxPlotSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 if (series) {
                     // Connect to axis changed signals (unless this is a pie series)
                     if (!qobject_cast<DeclarativePieSeries *>(series)) {
                         connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                     }
                     series->setName(name);
                     m_chart->addSeries(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                     if (series->attachedAxes().count() < 2)
                         initializeAxes(series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis)
                     m_chart->setAxisX(axis, series);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis)
                     m_chart->setAxisY(axis, series);
             }
             void DeclarativeChart::createDefaultAxes()
             {
                 qWarning() << "ChartView.createDefaultAxes() is deprecated. Axes are created automatically.";
             }
             QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series)
             {
                 if (!series) {
                     qWarning() << "No axis type defined for null series";
                     return 0;
                 }
                 foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) {
                     if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation))
                         return existingAxis;
                 }
                 switch (series->d_ptr->defaultAxisType(orientation)) {
                 case QAbstractAxis::AxisTypeValue:
                     return new QValueAxis(this);
                 case QAbstractAxis::AxisTypeBarCategory:
                     return new QBarCategoryAxis(this);
                 case QAbstractAxis::AxisTypeCategory:
                     return new QCategoryAxis(this);
             #ifndef QT_ON_ARM
                 case QAbstractAxis::AxisTypeDateTime:
                     return new QDateTimeAxis(this);
             #endif
                 case QAbstractAxis::AxisTypeLogValue:
                     return new QLogValueAxis(this);
                 default:
                     // assume AxisTypeNoAxis
                     return 0;
                 }
             }
             void DeclarativeChart::initializeAxes(QAbstractSeries *series)
             {
                 if (qobject_cast<DeclarativeLineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeLineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeScatterSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeScatterSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeSplineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeSplineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeAreaSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeAreaSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativePercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativePercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBoxPlotSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBoxPlotSeries *>(series)->m_axes);
                 // else: do nothing
             }
             void DeclarativeChart::doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes)
             {
                 // Initialize axis X
                 if (axes->axisX())
                     axes->emitAxisXChanged();
                 else if (axes->axisXTop())
                     axes->emitAxisXTopChanged();
                 else
                     axes->setAxisX(defaultAxis(Qt::Horizontal, series));
                 // Initialize axis Y
                 if (axes->axisY())
                     axes->emitAxisYChanged();
                 else if (axes->axisYRight())
                     axes->emitAxisYRightChanged();
                 else
                     axes->setAxisY(defaultAxis(Qt::Vertical, series));
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativechart.h +5 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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <QtCore/QtGlobal>
             #include "shared_defines.h"
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQuick/QQuickItem>
             #include <QtQuick/QQuickPaintedItem>
             #include <QtWidgets/QGraphicsScene>
             #include <QtCore/QMutex>
             #else
             #include <QtDeclarative/QDeclarativeItem>
             #endif
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeMargins;
             class Domain;
             class DeclarativeAxes;
             class DeclarativeChart : public QDECLARATIVE_PAINTED_ITEM
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QLegend *legend READ legend CONSTANT)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)
                 Q_PROPERTY(bool dropShadowEnabled READ dropShadowEnabled WRITE setDropShadowEnabled NOTIFY dropShadowEnabledChanged)
                 Q_PROPERTY(qreal backgroundRoundness READ backgroundRoundness WRITE setBackgroundRoundness NOTIFY backgroundRoundnessChanged REVISION 3)
                 Q_PROPERTY(qreal topMargin READ topMargin)
                 Q_PROPERTY(qreal bottomMargin READ bottomMargin)
                 Q_PROPERTY(qreal leftMargin READ leftMargin)
                 Q_PROPERTY(qreal rightMargin READ rightMargin)
                 Q_PROPERTY(DeclarativeMargins *minimumMargins READ minimumMargins NOTIFY minimumMarginsChanged REVISION 1)
                 Q_PROPERTY(DeclarativeMargins *margins READ margins NOTIFY marginsChanged REVISION 2)
                 Q_PROPERTY(QRectF plotArea READ plotArea NOTIFY plotAreaChanged REVISION 1)
                 Q_PROPERTY(QColor plotAreaColor READ plotAreaColor WRITE setPlotAreaColor NOTIFY plotAreaColorChanged REVISION 3)
             #ifdef CHARTS_FOR_QUICK2
                 Q_PROPERTY(QQmlListProperty<QAbstractAxis> axes READ axes REVISION 2)
             #else
                 Q_PROPERTY(QDeclarativeListProperty<QAbstractAxis> axes READ axes REVISION 2)
             #endif
+                Q_PROPERTY(bool localizeNumbers READ localizeNumbers WRITE setLocalizeNumbers NOTIFY localizeNumbersChanged REVISION 4)
                 Q_ENUMS(Animation)
                 Q_ENUMS(Theme)
                 Q_ENUMS(SeriesType)
             public:
                 // duplicating enums from QChart to make the QML api namings 1-to-1 with the C++ api
                 enum Theme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy,
                     ChartThemeQt
                 };
                 enum Animation {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypeBoxPlot,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             public:
                 DeclarativeChart(QDECLARATIVE_ITEM *parent = 0);
                 ~DeclarativeChart();
             public: // From parent classes
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
             #ifdef CHARTS_FOR_QUICK2
                 void paint(QPainter *painter);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void hoverMoveEvent(QHoverEvent *event);
             private Q_SLOTS:
                 void handleAntialiasingChanged(bool enable);
                 void sceneChanged(QList<QRectF> region);
                 void renderScene();
             #endif
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 QFont titleFont() const;
                 void setTitleFont(const QFont &font);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
                 Q_REVISION(3) void setPlotAreaColor(QColor color);
                 Q_REVISION(3) QColor plotAreaColor();
+                Q_REVISION(4) void setLocalizeNumbers(bool localize);
+                Q_REVISION(4) bool localizeNumbers() const;
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 Q_REVISION(3) qreal backgroundRoundness() const;
                 Q_REVISION(3) void setBackgroundRoundness(qreal diameter);
                 // Margins & plotArea
                 qreal topMargin();
                 qreal bottomMargin();
                 qreal leftMargin();
                 qreal rightMargin();
                 DeclarativeMargins *minimumMargins() { return m_margins; }
                 Q_REVISION(2) DeclarativeMargins *margins() { return m_margins; }
                 QRectF plotArea() { return m_chart->plotArea(); }
                 // Axis handling
                 QAbstractAxis *defaultAxis(Qt::Orientation orientation, QAbstractSeries *series);
                 void initializeAxes(QAbstractSeries *series);
                 void doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes);
                 QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> axes();
                 static void axesAppendFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, QAbstractAxis *element);
                 static int axesCountFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list);
                 static QAbstractAxis *axesAtFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, int index);
                 static void axesClearFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list);
             public:
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(int type, QString name = "", QAbstractAxis *axisX = 0, QAbstractAxis *axisY = 0);
                 Q_INVOKABLE void removeSeries(QAbstractSeries *series);
                 Q_INVOKABLE void removeAllSeries() { m_chart->removeAllSeries(); }
                 Q_INVOKABLE void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void createDefaultAxes();
                 Q_INVOKABLE QAbstractAxis *axisX(QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisY(QAbstractSeries *series = 0);
                 Q_INVOKABLE void zoom(qreal factor);
                 Q_INVOKABLE void scrollLeft(qreal pixels);
                 Q_INVOKABLE void scrollRight(qreal pixels);
                 Q_INVOKABLE void scrollUp(qreal pixels);
                 Q_INVOKABLE void scrollDown(qreal pixels);
             Q_SIGNALS:
                 void axisLabelsChanged();
                 void titleColorChanged(QColor color);
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
                 void minimumMarginsChanged();
                 Q_REVISION(2) void marginsChanged();
                 void plotAreaChanged(QRectF plotArea);
                 void seriesAdded(QAbstractSeries *series);
                 void seriesRemoved(QAbstractSeries *series);
                 Q_REVISION(3) void plotAreaColorChanged();
                 Q_REVISION(3) void backgroundRoundnessChanged(qreal diameter);
+                Q_REVISION(4) bool localizeNumbersChanged();
             private Q_SLOTS:
                 void changeMinimumMargins(int top, int bottom, int left, int right);
                 void handleAxisXSet(QAbstractAxis *axis);
                 void handleAxisYSet(QAbstractAxis *axis);
                 void handleAxisXTopSet(QAbstractAxis *axis);
                 void handleAxisYRightSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series);
             protected:
                 explicit DeclarativeChart(QChart::ChartType type, QDECLARATIVE_ITEM *parent);
             private:
                 void initChart(QChart::ChartType type);
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
             #ifdef CHARTS_FOR_QUICK2
                 QGraphicsScene *m_scene;
                 QPointF m_mousePressScenePoint;
                 QPoint m_mousePressScreenPoint;
                 QPointF m_lastMouseMoveScenePoint;
                 QPoint m_lastMouseMoveScreenPoint;
                 Qt::MouseButton m_mousePressButton;
                 Qt::MouseButtons m_mousePressButtons;
                 QMutex m_sceneImageLock;
                 QImage *m_currentSceneImage;
                 bool m_updatePending;
                 Qt::HANDLE m_paintThreadId;
                 Qt::HANDLE m_guiThreadId;
             #endif
                 DeclarativeMargins *m_margins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECHART_H

plugins/declarative/plugin.cpp +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$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "qlogvalueaxis.h"
             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
             #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativepieseries.h"
             #include "declarativeaxes.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include "declarativemargins.h"
             #include "qarealegendmarker.h"
             #include "qbarlegendmarker.h"
             #include "qpielegendmarker.h"
             #include "qxylegendmarker.h"
             #include "qboxplotmodelmapper.h"
             #include "qvboxplotmodelmapper.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #include "shared_defines.h"
             #include <QAbstractItemModel>
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlExtensionPlugin>
             #else
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #endif
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QList<QPieSlice *>)
             Q_DECLARE_METATYPE(QList<QBarSet *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
             Q_DECLARE_METATYPE(DeclarativeChart *)
             Q_DECLARE_METATYPE(DeclarativePolarChart *)
             Q_DECLARE_METATYPE(DeclarativeMargins *)
             Q_DECLARE_METATYPE(DeclarativeAreaSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSet *)
             Q_DECLARE_METATYPE(DeclarativeBoxPlotSeries *)
             Q_DECLARE_METATYPE(DeclarativeBoxSet *)
             Q_DECLARE_METATYPE(DeclarativeLineSeries *)
             Q_DECLARE_METATYPE(DeclarativePieSeries *)
             Q_DECLARE_METATYPE(DeclarativePieSlice *)
             Q_DECLARE_METATYPE(DeclarativeScatterSeries *)
             Q_DECLARE_METATYPE(DeclarativeSplineSeries *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QCategoryAxis *)
             Q_DECLARE_METATYPE(QDateTimeAxis *)
             Q_DECLARE_METATYPE(QLogValueAxis *)
             Q_DECLARE_METATYPE(QLegend *)
             Q_DECLARE_METATYPE(QLegendMarker *)
             Q_DECLARE_METATYPE(QAreaLegendMarker *)
             Q_DECLARE_METATYPE(QBarLegendMarker *)
             Q_DECLARE_METATYPE(QPieLegendMarker *)
             Q_DECLARE_METATYPE(QHPieModelMapper *)
             Q_DECLARE_METATYPE(QHXYModelMapper *)
             Q_DECLARE_METATYPE(QPieModelMapper *)
             Q_DECLARE_METATYPE(QHBarModelMapper *)
             Q_DECLARE_METATYPE(QBarModelMapper *)
             Q_DECLARE_METATYPE(QVBarModelMapper *)
             Q_DECLARE_METATYPE(QVPieModelMapper *)
             Q_DECLARE_METATYPE(QVXYModelMapper *)
             Q_DECLARE_METATYPE(QXYLegendMarker *)
             Q_DECLARE_METATYPE(QXYModelMapper *)
             Q_DECLARE_METATYPE(QBoxPlotModelMapper *)
             Q_DECLARE_METATYPE(QVBoxPlotModelMapper *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QXYSeries *)
             Q_DECLARE_METATYPE(QAbstractBarSeries *)
             Q_DECLARE_METATYPE(QBarSeries *)
             Q_DECLARE_METATYPE(QBarSet *)
             Q_DECLARE_METATYPE(QAreaSeries *)
             Q_DECLARE_METATYPE(QHorizontalBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalPercentBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalStackedBarSeries *)
             Q_DECLARE_METATYPE(QLineSeries *)
             Q_DECLARE_METATYPE(QPercentBarSeries *)
             Q_DECLARE_METATYPE(QPieSeries *)
             Q_DECLARE_METATYPE(QPieSlice *)
             Q_DECLARE_METATYPE(QScatterSeries *)
             Q_DECLARE_METATYPE(QSplineSeries *)
             Q_DECLARE_METATYPE(QStackedBarSeries *)
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDECLARATIVE_EXTENSION_PLUGIN
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
             #else
             # if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDeclarativeExtensionInterface")
             # endif
             #endif
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     qRegisterMetaType<QList<QAbstractAxis *> >();
                     // QtCommercial.Chart 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 1, 0, "DeclarativeAxes",
                                                            QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCommercial.Chart 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 2>(uri, 1, 2, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 2>(uri, 1, 2, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 2>(uri, 1, 2, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 2>(uri, 1, 2, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 1, 2, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 1, 2, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 1, 2, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
                     // QtCommercial.Chart 1.3
                     qmlRegisterType<DeclarativeChart, 3>(uri, 1, 3, "ChartView");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
                     qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                     qmlRegisterType<QLogValueAxis>(uri, 1, 3, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries>(uri, 1, 3, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet>(uri, 1, 3, "BoxSet");
                     // QtCommercial.Chart 1.4
                     qmlRegisterType<DeclarativeAreaSeries, 4>(uri, 1, 4, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSet, 2>(uri, 1, 4, "BarSet");
                     qmlRegisterType<DeclarativeBoxPlotSeries, 1>(uri, 1, 4, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet, 1>(uri, 1, 4, "BoxSet");
                     qmlRegisterType<DeclarativePieSlice>(uri, 1, 4, "PieSlice");
                     qmlRegisterType<DeclarativeScatterSeries, 4>(uri, 1, 4, "ScatterSeries");
                     // QtCommercial.Chart 2.0
                     qmlRegisterType<QVBoxPlotModelMapper>(uri, 2, 0, "VBoxPlotModelMapper");
                     qmlRegisterUncreatableType<QBoxPlotModelMapper>(uri, 2, 0, "BoxPlotModelMapper",
                         QLatin1String("Trying to create uncreatable: BoxPlotModelMapper."));
+                    qmlRegisterType<DeclarativeChart, 4>(uri, 2, 0, "ChartView");
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #include "plugin.moc"
             QTCOMMERCIALCHART_USE_NAMESPACE
             #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

src/areachart/areachartitem.cpp +8 -4

             /****************************************************************************
             **
             ** 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 "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item)
                 : ChartItem(areaSeries->d_func(),item),
                   m_series(areaSeries),
                   m_upper(0),
                   m_lower(0),
                   m_pointsVisible(false),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(areaSeries->pointLabelsFormat()),
                   m_pointLabelsFont(areaSeries->pointLabelsFont()),
                   m_pointLabelsColor(areaSeries->pointLabelsColor())
             {
                 setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::LineChartZValue);
                 if (m_series->upperSeries())
                     m_upper = new AreaBoundItem(this, m_series->upperSeries());
                 if (m_series->lowerSeries())
                     m_lower = new AreaBoundItem(this, m_series->lowerSeries());
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), areaSeries, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), areaSeries, SIGNAL(hovered(QPointF,bool)));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFontChanged(QFont)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsColorChanged(QColor)),
                                  this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             void AreaChartItem::setPresenter(ChartPresenter *presenter)
             {
                 if (m_upper)
                     m_upper->setPresenter(presenter);
                 if (m_lower) {
                     m_lower->setPresenter(presenter);
                 }
             	ChartItem::setPresenter(presenter);
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 QRectF rect(QPointF(0,0),domain()->size());
                 path = m_upper->path();
                 if (m_lower) {
                     // Note: Polarcharts always draw area correctly only when both series have equal width or are
                     // fully displayed. If one series is partally off-chart, the connecting line between
                     // the series does not attach to the end of the partially hidden series but to the point
                     // where it intersects the axis line. The problem is especially noticeable when one of the series
                     // is entirely off-chart, in which case the connecting line connects two ends of the
                     // visible series.
                     // This happens because we get the paths from linechart, which omits off-chart segments.
                     // To properly fix, linechart would need to provide true full path, in right, left, and the rest
                     // portions to enable proper clipping. However, combining those to single visually unified area
                     // would be a nightmare, since they would have to be painted separately.
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     if (presenter()->chartType() == QChart::ChartTypeCartesian) {
                         path.lineTo(last.x(), rect.bottom());
                         path.lineTo(first.x(), rect.bottom());
                     } else { // polar
                         path.lineTo(rect.center());
                     }
                 }
                 path.closeSubpath();
                 // Only zoom in if the bounding rect of the path fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (path.boundingRect().height() <= INT_MAX
                         && path.boundingRect().width() <= INT_MAX) {
                     prepareGeometryChange();
                     m_path = path;
                     m_rect = path.boundingRect();
                     update();
                 }
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 if (m_upper) {
                     AbstractDomain* d = m_upper->domain();
                     d->setSize(domain()->size());
                     d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                     m_upper->handleDomainUpdated();
                 }
                 if (m_lower) {
                     AbstractDomain* d = m_lower->domain();
                 	d->setSize(domain()->size());
                 	d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                 	m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 if (presenter()->chartType() == QChart::ChartTypePolar)
                     painter->setClipRegion(QRegion(clipRect.toRect(), QRegion::Ellipse));
                 else
                     painter->setClipRect(clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(m_upper->geometryPoints());
                     if (m_lower)
                         painter->drawPoints(m_lower->geometryPoints());
                 }
                 // Draw series point label
                 if (m_pointLabelsVisible) {
                     static const QString xPointTag(QLatin1String("@xPoint"));
                     static const QString yPointTag(QLatin1String("@yPoint"));
                     const int labelOffset = 2;
                     painter->setFont(m_pointLabelsFont);
                     painter->setPen(QPen(m_pointLabelsColor));
                     QFontMetrics fm(painter->font());
                     QString pointLabel = m_pointLabelsFormat;
                     if (m_series->upperSeries()) {
                         for (int i(0); i < m_series->upperSeries()->count(); i++) {
-                            pointLabel.replace(xPointTag, QString::number(m_series->upperSeries()->at(i).x()));
+                            pointLabel.replace(xPointTag,
-                            pointLabel.replace(yPointTag, QString::number(m_series->upperSeries()->at(i).y()));
+                                               presenter()->numberToString(m_series->upperSeries()->at(i).x()));
+                            pointLabel.replace(yPointTag,
+                                               presenter()->numberToString(m_series->upperSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_upper->geometryPoints().at(i));
                             position.setX(position.x() - pointLabelWidth / 2);
                             position.setY(position.y() - m_series->upperSeries()->pen().width() / 2 - labelOffset);
                             painter->drawText(position, pointLabel);
                         }
                     }
                     if (m_series->lowerSeries()) {
                         for (int i(0); i < m_series->lowerSeries()->count(); i++) {
-                            pointLabel.replace(xPointTag, QString::number(m_series->lowerSeries()->at(i).x()));
+                            pointLabel.replace(xPointTag,
-                            pointLabel.replace(yPointTag, QString::number(m_series->lowerSeries()->at(i).y()));
+                                               presenter()->numberToString(m_series->lowerSeries()->at(i).x()));
+                            pointLabel.replace(yPointTag,
+                                               presenter()->numberToString(m_series->lowerSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_lower->geometryPoints().at(i));
                             position.setX(position.x() - pointLabelWidth / 2);
                             position.setY(position.y() - m_series->lowerSeries()->pen().width() / 2 - labelOffset);
                             painter->drawText(position, pointLabel);
                         }
                     }
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->domain()->calculateDomainPoint(event->pos()));
                 ChartItem::mousePressEvent(event);
             }
             void AreaChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxiselement.cpp +86 -41

             /****************************************************************************
             **
             ** 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 QRegExp *labelFormatMatcher = 0;
+            static QRegExp *labelFormatMatcherLocalized = 0;
             class StaticLabelFormatMatcherDeleter
             {
             public:
                 StaticLabelFormatMatcherDeleter() {}
-                ~StaticLabelFormatMatcherDeleter() { delete labelFormatMatcher; }
+                ~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();
             }
-            static void appendFormattedLabel(const QString &capStr, const QByteArray &array,
+            QString ChartAxisElement::formatLabel(const QString &formatSpec, const QByteArray &array,
-                                             QStringList &labels, qreal value)
+                                                  qreal value, int precision, const QString &preStr,
+                                                  const QString &postStr) const
             {
-                if (capStr.isEmpty()) {
+                QString retVal;
-                    labels << QString();
+                if (!formatSpec.isEmpty()) {
-                } else if (capStr.at(0) == QLatin1Char('d')
+                    if (formatSpec.at(0) == QLatin1Char('d')
-                    || capStr.at(0) == QLatin1Char('i')
+                        || formatSpec.at(0) == QLatin1Char('i')
-                    || capStr.at(0) == QLatin1Char('c')) {
+                        || formatSpec.at(0) == QLatin1Char('c')) {
-                    labels << QString().sprintf(array, (qint64)value);
+                        if (presenter()->localizeNumbers())
-                } else if (capStr.at(0) == QLatin1Char('u')
+                            retVal = preStr + presenter()->locale().toString(qint64(value)) + postStr;
-                         || capStr.at(0) == QLatin1Char('o')
+                        else
-                         || capStr.at(0) == QLatin1Char('x')
+                            retVal = QString().sprintf(array, qint64(value));
-                         || capStr.at(0) == QLatin1Char('X')) {
+                    } else if (formatSpec.at(0) == QLatin1Char('u')
-                    labels << QString().sprintf(array, (quint64)value);
+                             || formatSpec.at(0) == QLatin1Char('o')
-                } else if (capStr.at(0) == QLatin1Char('f')
+                             || formatSpec.at(0) == QLatin1Char('x')
-                           || capStr.at(0) == QLatin1Char('F')
+                             || formatSpec.at(0) == QLatin1Char('X')) {
-                           || capStr.at(0) == QLatin1Char('e')
+                        // These formats are not supported by localized numbers
-                           || capStr.at(0) == QLatin1Char('E')
+                        retVal = QString().sprintf(array, quint64(value));
-                           || capStr.at(0) == QLatin1Char('g')
+                    } else if (formatSpec.at(0) == QLatin1Char('f')
-                           || capStr.at(0) == QLatin1Char('G')) {
+                               || formatSpec.at(0) == QLatin1Char('F')
-                    labels << QString().sprintf(array, value);
+                               || 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 {
-                    labels << QString();
+                            retVal = QString().sprintf(array, value);
+                        }
                     }
                 }
+                return retVal;
+            }
-            QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks, const QString &format)
+            QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks,
+                                                            const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
-                int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
-                n++;
                 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 << QString::number(value, 'f', n);
+                        labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
-                    QString capStr;
+                    QString formatSpec;
+                    QString preStr;
+                    QString postStr;
+                    int precision = 0;
+                    if (presenter()->localizeNumbers()) {
+                        if (!labelFormatMatcherLocalized)
+                            labelFormatMatcherLocalized = new QRegExp(labelFormatMatchLocalizedString);
+                        if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
+                            preStr = labelFormatMatcherLocalized->cap(1);
+                            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)
-                        capStr = labelFormatMatcher->cap(1);
+                            formatSpec = labelFormatMatcher->cap(1);
+                    }
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
-                        appendFormattedLabel(capStr, array, labels, value);
+                        labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
-            QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format)
+            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 n = 0;
-                if (ticks > 1)
-                    n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
-                n++;
                 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 << QString::number(value, 'f', n);
+                        labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
-                    QString capStr;
+                    QString formatSpec;
+                    QString preStr;
+                    QString postStr;
+                    int precision = 0;
+                    if (presenter()->localizeNumbers()) {
+                        if (!labelFormatMatcherLocalized)
+                            labelFormatMatcherLocalized = new QRegExp(labelFormatMatchLocalizedString);
+                        if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
+                            preStr = labelFormatMatcherLocalized->cap(1);
+                            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)
-                        capStr = labelFormatMatcher->cap(1);
+                            formatSpec = labelFormatMatcher->cap(1);
+                    }
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
-                        appendFormattedLabel(capStr, array, labels, value);
+                        labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
-            QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,const QString &format)
+            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 << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxiselement_p.h +7 -3

             /****************************************************************************
             **
             ** 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 CHARTAXISELEMENT_H
             #define CHARTAXISELEMENT_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractAxis;
             class ChartAxisElement : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 using QGraphicsLayoutItem::setGeometry;
             public:
                 ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~ChartAxisElement();
                 virtual QRectF gridGeometry() const = 0;
                 virtual void setGeometry(const QRectF &axis, const QRectF &grid) = 0;
                 virtual bool isEmpty() = 0;
                 void setAnimation(AxisAnimation *animation) { m_animation = animation; }
                 AxisAnimation *animation() const { return m_animation; }
                 QAbstractAxis *axis() const { return m_axis; }
                 void setLayout(QVector<qreal> &layout) { m_layout = layout; }
                 QVector<qreal> &layout() { return m_layout; } // Modifiable reference
                 inline qreal labelPadding() const { return qreal(4.0); }
                 inline qreal titlePadding() const { return qreal(2.0); }
                 void setLabels(const QStringList &labels) { m_labelsList = labels; }
                 QStringList labels() const { return m_labelsList; }
                 qreal min() const;
                 qreal max() const;
                 QRectF axisGeometry() const { return m_axisRect; }
                 void setAxisGeometry(const QRectF &axisGeometry) { m_axisRect = axisGeometry; }
                 void axisSelected();
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
-                static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
+                QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format) const;
-                static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format);
+                QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks,
-                static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
+                                                 const QString &format) const;
+                QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format) const;
                 // from QGraphicsLayoutItem
                 QRectF boundingRect() const
                 {
                     return QRectF();
                 }
                 // from QGraphicsLayoutItem
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             protected:
                 virtual QVector<qreal> calculateLayout() const = 0;
                 virtual void updateLayout(QVector<qreal> &layout) = 0;
                 QList<QGraphicsItem *> gridItems() { return m_grid->childItems(); }
                 QList<QGraphicsItem *> labelItems() { return m_labels->childItems(); }
                 QList<QGraphicsItem *> shadeItems() { return m_shades->childItems(); }
                 QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems(); }
                 QGraphicsTextItem *titleItem() const { return m_title.data(); }
                 QGraphicsItemGroup *gridGroup() { return m_grid.data(); }
                 QGraphicsItemGroup *labelGroup() { return m_labels.data(); }
                 QGraphicsItemGroup *shadeGroup() { return m_shades.data(); }
                 QGraphicsItemGroup *arrowGroup() { return m_arrow.data(); }
             public Q_SLOTS:
                 void handleVisibleChanged(bool visible);
                 void handleArrowVisibleChanged(bool visible);
                 void handleGridVisibleChanged(bool visible);
                 void handleLabelsVisibleChanged(bool visible);
                 void handleShadesVisibleChanged(bool visible);
                 void handleLabelsAngleChanged(int angle);
                 virtual void handleShadesBrushChanged(const QBrush &brush) = 0;
                 virtual void handleShadesPenChanged(const QPen &pen) = 0;
                 virtual void handleArrowPenChanged(const QPen &pen) = 0;
                 virtual void handleGridPenChanged(const QPen &pen) = 0;
                 void handleLabelsPenChanged(const QPen &pen);
                 void handleLabelsBrushChanged(const QBrush &brush);
                 void handleLabelsFontChanged(const QFont &font);
                 void handleTitlePenChanged(const QPen &pen);
                 void handleTitleBrushChanged(const QBrush &brush);
                 void handleTitleFontChanged(const QFont &font);
                 void handleTitleTextChanged(const QString &title);
                 void handleTitleVisibleChanged(bool visible);
                 void handleRangeChanged(qreal min, qreal max);
             Q_SIGNALS:
                 void clicked();
             private:
                 void connectSlots();
+                QString formatLabel(const QString &formatSpec, const QByteArray &array,
+                                    qreal value, int precision, const QString &preStr,
+                                    const QString &postStr) const;
                 QAbstractAxis *m_axis;
                 AxisAnimation *m_animation;
                 QVector<qreal> m_layout;
                 QStringList m_labelsList;
                 QRectF m_axisRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsTextItem> m_title;
                 bool m_intervalAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXISELEMENT_H */

src/axis/valueaxis/qvalueaxis.cpp +10 -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, c
+              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
+              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, c
+              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
+              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/abstractbarchartitem.cpp +5 -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 "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             #include "baranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(handleUpdatedBars()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
                 handleVisibleChanged();
                 handleUpdatedBars();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 QSizeF size = geometry().size();
                 if (geometry().size().isValid()) {
                     if (m_animation) {
                         if (m_layout.count() == 0 || m_oldSize != size) {
                             initializeLayout();
                             m_oldSize = size;
                         }
                         m_animation->setup(m_layout, layout);
                         presenter()->startAnimation(m_animation);
                     } else {
                         setLayout(layout);
                         update();
                     }
                 }
             }
             void AbstractBarChartItem::setAnimation(BarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i = 0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
                 positionLabels();
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 QRectF rect(QPointF(0,0),domain()->size());
                 if(m_rect != rect){
                     prepareGeometryChange();
                     m_rect = rect;
                 }
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0))
                     return; // rect size zero.
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 handleUpdatedBars();
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsTextItem *label, m_labels)
                     label->setVisible(visible);
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set, c, this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), m_series, SIGNAL(hovered(bool,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool, int, QBarSet*)), m_series, SIGNAL(hovered(bool, int, QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), set, SIGNAL(hovered(bool)));
                         connect(bar, SIGNAL(hovered(bool, int, QBarSet*)), set, SIGNAL(hovered(bool, int)));
                         //            m_layout.append(QRectF(0, 0, 1, 1));
                         // Labels
                         QGraphicsTextItem *newLabel = new QGraphicsTextItem(this);
                         newLabel->document()->setDocumentMargin(ChartPresenter::textMargin());
                         m_labels.append(newLabel);
                     }
                 }
                 if(themeManager()) themeManager()->updateSeries(m_series);
                 handleLayoutChanged();
                 handleVisibleChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 if (visible)
                     handleLabelsVisibleChanged(m_series->isLabelsVisible());
                 else
                     handleLabelsVisibleChanged(visible);
                 foreach (QGraphicsItem *bar, m_bars)
                     bar->setVisible(visible);
             }
             void AbstractBarChartItem::handleOpacityChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     item->setOpacity(m_series->opacity());
             }
             void AbstractBarChartItem::handleUpdatedBars()
             {
                 if (!m_series->d_func()->blockBarUpdate()) {
                     // Handle changes in pen, brush, labels etc.
                     int categoryCount = m_series->d_func()->categoryCount();
                     int setCount = m_series->count();
                     int itemIndex(0);
                     static const QString valueTag(QLatin1String("@value"));
                     for (int category = 0; category < categoryCount; category++) {
                         for (int set = 0; set < setCount; set++) {
                             QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                             Bar *bar = m_bars.at(itemIndex);
                             bar->setPen(barSet->m_pen);
                             bar->setBrush(barSet->m_brush);
                             bar->update();
                             QGraphicsTextItem *label = m_labels.at(itemIndex);
                             QString valueLabel;
+                            if (presenter()) { // At startup presenter is not yet set, yet somehow update comes
                                 if (m_series->labelsFormat().isEmpty()) {
-                                valueLabel = QString("%1").arg(barSet->value(category));
+                                    valueLabel = presenter()->numberToString(barSet->value(category));
                                 } else {
                                     valueLabel = m_series->labelsFormat();
-                                valueLabel.replace(valueTag, QString::number(barSet->value(category)));
+                                    valueLabel.replace(valueTag,
+                                                       presenter()->numberToString(barSet->value(category)));
+                                }
                             }
                             label->setHtml(valueLabel);
                             label->setFont(barSet->m_labelFont);
                             label->setDefaultTextColor(barSet->m_labelBrush.color());
                             label->update();
                             itemIndex++;
                         }
                     }
                 }
             }
             void AbstractBarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void AbstractBarChartItem::positionLabels()
             {
                 for (int i = 0; i < m_layout.count(); i++) {
                     QGraphicsTextItem *label = m_labels.at(i);
                     qreal xPos = 0;
                     qreal yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
                     int offset = m_bars.at(i)->pen().width() / 2 + 2;
                     if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
                         xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
                         xPos = m_layout.at(i).right() - label->boundingRect().width() - offset;
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
                         xPos = m_layout.at(i).left() + offset;
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
                         xPos = m_layout.at(i).right() + offset;
                     label->setPos(xPos, yPos);
                     label->setZValue(zValue() + 1);
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +4 -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 "horizontalpercentbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
                 : AbstractBarChartItem(series, item)
             {
             }
             void HorizontalPercentBarChartItem::initializeLayout()
             {
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 m_layout.clear();
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
                             topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category + barWidth / 2), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(0, category + barWidth / 2), m_validData);
                         }
                         if (!m_validData)
                              return;
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         m_layout.append(rect.normalized());
                     }
                 }
             }
             QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         qreal topX = 0;
                         if (sum > 0)
                             topX = 100 * sum / categorySum;
                         qreal bottomX = 0;
                         qreal newSum = value + sum;
                         if (newSum > 0)
                             bottomX = 100 * newSum / categorySum;
                         QPointF topLeft;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             topLeft = domain()->calculateGeometryPoint(QPointF(set ? topX : domain()->minX(), category - barWidth/2), m_validData);
                         else
                             topLeft = domain()->calculateGeometryPoint(QPointF(set ? topX : 0, category - barWidth/2), m_validData);
                         QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(bottomX, category + barWidth/2), m_validData);
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                         sum = newSum;
                     }
                 }
                 return layout;
             }
             void HorizontalPercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 static const QString valueTag(QLatin1String("@value"));
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsTextItem *label = m_labels.at(itemIndex);
-                        int p = m_series->d_func()->percentageAt(set, category) * 100;
+                        qreal p = m_series->d_func()->percentageAt(set, category) * 100.0;
-                        QString vString(QString::number(p));
+                        QString vString(presenter()->numberToString(p, 'f', 0));
-                        vString.truncate(3);
-                        vString.append("%");
                         QString valueLabel;
                         if (m_series->labelsFormat().isEmpty()) {
+                            vString.append("%");
                             valueLabel = vString;
                         } else {
                             valueLabel = m_series->labelsFormat();
-                            valueLabel.replace(valueTag, QString::number(barSet->value(category)));
+                            valueLabel.replace(valueTag, vString);
                         }
                         label->setHtml(valueLabel);
                         label->setFont(barSet->m_labelFont);
                         label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_horizontalpercentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/percentbarchartitem.cpp +4 -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 "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
             }
             void PercentBarChartItem::initializeLayout()
             {
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 m_layout.clear();
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, domain()->minY()), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0), m_validData);
                         }
                         if (!m_validData)
                              return;
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         m_layout.append(rect.normalized());
                     }
                 }
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         qreal topY = 0;
                         qreal newSum = value + sum;
                         if (newSum > 0)
                             topY = 100 * newSum / categorySum;
                         qreal bottomY = 0;
                         if (sum > 0)
                             bottomY = 100 * sum / categorySum;
                         QPointF topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth/2, topY), m_validData);
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? bottomY : domain()->minY()), m_validData);
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? bottomY : 0), m_validData);
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                         sum = newSum;
                     }
                 }
                 return layout;
             }
             void PercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 static const QString valueTag(QLatin1String("@value"));
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsTextItem *label = m_labels.at(itemIndex);
-                        int p = m_series->d_func()->percentageAt(set, category) * 100;
+                        qreal p = m_series->d_func()->percentageAt(set, category) * 100.0;
-                        QString vString(QString::number(p));
+                        QString vString(presenter()->numberToString(p, 'f', 0));
-                        vString.truncate(3);
-                        vString.append("%");
                         QString valueLabel;
                         if (m_series->labelsFormat().isEmpty()) {
+                            vString.append("%");
                             valueLabel = vString;
                         } else {
                             valueLabel = m_series->labelsFormat();
-                            valueLabel.replace(valueTag, QString::number(barSet->value(category)));
+                            valueLabel.replace(valueTag, vString);
                         }
                         label->setHtml(valueLabel);
                         label->setFont(barSet->m_labelFont);
                         label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             void PercentBarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void PercentBarChartItem::positionLabels()
             {
                 for (int i = 0; i < m_layout.count(); i++) {
                     QGraphicsTextItem *label = m_labels.at(i);
                     qreal xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
                     qreal yPos = 0;
                     int offset = m_bars.at(i)->pen().width() / 2 + 2;
                     if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
                         yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
                         yPos = m_layout.at(i).top() - offset;
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
                         yPos = m_layout.at(i).bottom() - label->boundingRect().height() + offset;
                     else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
                         yPos = m_layout.at(i).top() - label->boundingRect().height() + offset;
                     label->setPos(xPos, yPos);
                     label->setZValue(zValue() + 1);
                 }
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +22 -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 "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_title(0),
+                  m_localizeNumbers(false)
             {
                 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();
+            }
+            bool ChartPresenter::localizeNumbers() const
+            {
+                return m_localizeNumbers;
+            }
             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);
+            }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +10 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);
+                bool localizeNumbers() const;
                 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);
+                inline const QLocale &locale() const { return m_locale; }
             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 */

src/qabstractseries.cpp +10 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 "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \inmodule Qt Charts
                 \brief Base class for all Qt Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             #ifdef QDOC_QT5
             /*!
                 \qmltype AbstractSeries
                 \instantiates QAbstractSeries
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/abstractseries.qdocinc
             */
             #else
             /*!
                 \qmlclass AbstractSeries QAbstractSeries
                 \include ../doc/src/abstractseries.qdocinc
             */
             #endif
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
                 \value SeriesTypeBoxPlot
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \internal
                 \brief Constructs QAbstractSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Series still bound to a chart when destroyed!");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 \brief Sets the visibility of the series to true.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \note If multiple axes of same orientation are attached to same series,
                    they will have same min/max ranges.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
+            void QAbstractSeriesPrivate::setPresenter(ChartPresenter *presenter)
+            {
+                m_presenter = presenter;
+            }
+            ChartPresenter *QAbstractSeriesPrivate::presenter() const
+            {
+                return m_presenter;
+            }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_UNUSED(options);
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries_p.h +4 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 QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include "qabstractseries.h"
             #include "qchart.h"
             #include "abstractdomain_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartElement;
             class LegendMarker;
             class QLegend;
             class ChartDataSet;
             class QAbstractAxis;
             class QLegendMarker;
             class ChartTheme;
             class ChartAnimation;
             class ChartItem;
             class BoxPlotChartItem;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void initializeDomain() = 0;
                 virtual void initializeAxes() = 0;
                 virtual void initializeTheme(int index, ChartTheme* theme, bool forced = false) = 0;
                 virtual void initializeGraphics(QGraphicsItem* parent) = 0;
                 virtual void initializeAnimations(QChart::AnimationOptions options) = 0;
                 virtual QList<QLegendMarker*> createLegendMarkers(QLegend* legend) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
                 virtual QAbstractAxis* createDefaultAxis(Qt::Orientation) const = 0;
                 ChartItem* chartItem() { return m_item.data(); }
                 virtual void setDomain(AbstractDomain* domain);
                 AbstractDomain* domain() { return m_domain.data(); }
+                virtual void setPresenter(ChartPresenter *presenter);
+                ChartPresenter *presenter() const;
                 QChart* chart() { return m_chart; }
             Q_SIGNALS:
                 void countChanged();
             protected:
                 QAbstractSeries *q_ptr;
                 QChart *m_chart;
                 QScopedPointer<ChartItem> m_item;
                 QList<QAbstractAxis*> m_axes;
             private:
                 QScopedPointer<AbstractDomain> m_domain;
                 QString m_name;
                 bool m_visible;
                 qreal m_opacity;
+                ChartPresenter *m_presenter;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
                 friend class BoxPlotChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchart.cpp +19 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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "abstractchartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              \value ChartThemeQt
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \enum QChart::ChartType
              This enum describes the chart type.
              \value ChartTypeUndefined
              \value ChartTypeCartesian
              \value ChartTypePolar
              */
             /*!
              \class QChart
              \inmodule Qt Charts
              \brief Main chart API for Qt Charts.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like legend and
              axes. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView, QPolarChart
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Specifies whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::backgroundRoundness
              The diameter of the rounding cirle at the corners of the chart background.
              */
             /*!
              \property QChart::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              This property is deprecated; use margins property instead.
              \sa margins
              */
             /*!
              \property QChart::margins
              Margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes, and fonts of series, axes, title, and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              \note Changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart. Chart title supports html formatting.
              */
             /*!
              \property QChart::chartType
              Chart type indicates if the chart is a cartesian chart or a polar chart.
              This property is set internally and it is read only.
              \sa QPolarChart
              */
             /*!
              \property QChart::plotAreaBackgroundVisible
              Specifies whether the chart plot area background is visible or not.
              \note By default the plot area background is not visible and the plot area uses
              the general chart background.
              \sa setPlotAreaBackgroundBrush(), setPlotAreaBackgroundPen(), backgroundVisible
              */
             /*!
+              \property QChart::localizeNumbers
+              \since QtCharts 2.0
+              When \c{true}, all generated numbers appearing in various series and axis labels will be
+              localized using the default QLocale of the application, which defaults to the system locale.
+              When \c{false}, the "C" locale is always used.
+              Defaults to \c{false}.
+            */
+            /*!
              \internal
              Constructs a chart object of \a type which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              This constructor is called only by subclasses.
             */
             QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, type))
             {
                 d_ptr->init();
             }
             /*!
              Constructs a chart object which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, ChartTypeCartesian))
             {
                 d_ptr->init();
             }
             /*!
              Destroys the chart object and its children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of it.
              \note A newly added series is attached to no axes by default, including any axes that were created for the chart
              using createDefaultAxes() before the series was added to the chart. If no axes are attached to
              the newly added series before the chart is shown, the series will get drawn as if it had axes with ranges
              that exactly fit the series to the plot area of the chart. This can be confusing if the same chart also displays other
              series that have properly attached axes, so always make sure you either call createDefaultAxes() after
              a series has been added or explicitly attach axes for the series.
              \sa removeSeries(), removeAllSeries(), createDefaultAxes(), QAbstractSeries::attachAxis()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series from the chart.
              The chart releases its ownership of the specified \a series object.
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes and deletes all series objects that have been added to the chart.
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                     removeSeries(s);
                     delete s;
                 }
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
              Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
              Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart title.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
              Gets the font that is used for drawing the chart title.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for drawing the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for drawing the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
              Zooms in the view by a factor of two.
              */
             void QChart::zoomIn()
             {
                 d_ptr->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              \note This is not supported for polar charts.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 if (d_ptr->m_type == QChart::ChartTypePolar)
                     return;
                 d_ptr->zoomIn(rect);
             }
             /*!
              Zooms out the view by a factor of two.
              */
             void QChart::zoomOut()
             {
                 d_ptr->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a custom \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
              Resets the series domains to what they were before any zoom method was called.
              Note that this will also reset any scrolls and explicit axis range settings done between
              the first zoom operation and calling this method. If no zoom operation has been
              done, this method does nothing.
              */
             void QChart::zoomReset()
             {
                 d_ptr->zoomReset();
             }
             /*!
              Returns true if any series has a zoomed domain.
              */
             bool QChart::isZoomed()
             {
                return d_ptr->isZoomed();
             }
             /*!
              Returns a pointer to the horizontal axis attached to the specified \a series.
              If no \a series is specified, the first horizontal axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns a pointer to the vertical axis attached to the specified \a series.
              If no \a series is specified, the first vertical axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns the axes attached to the \a series with \a orientation. If no \a series is provided,
              then all axes added to the chart with the specified orientation are returned.
              \sa addAxis(), createDefaultAxes()
              */
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 if (series) {
                     foreach (QAbstractAxis *axis, series->attachedAxes()){
                         if (orientation.testFlag(axis->orientation()))
                             result << axis;
                     }
                 } else {
                     foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                         if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                             result << axis;
                     }
                 }
                 return result;
             }
             /*!
              Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to
              the chart will be deleted.
              \note This function has to be called after all series have been added to the chart. The axes created by this function
              will NOT get automatically attached to any series added to the chart after this function has been called.
              A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing
              if there are other series with properly attached axes also present.
              \table
                  \header
                      \li Series type
                      \li X-axis
                      \li Y-axis
                  \row
                      \li QXYSeries
                      \li QValueAxis
                      \li QValueAxis
                  \row
                      \li QBarSeries
                      \li QBarCategoryAxis
                      \li QValueAxis
                  \row
                      \li QPieSeries
                      \li None
                      \li None
              \endtable
              If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created.
              If there are several series of different types added to the chart, then each series gets its own axes pair.
              The axes specific to the series can be later obtained from the chart by providing the series as the parameter for axes() function call.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), axes(), setAxisX(), setAxisY(), QAbstractSeries::attachAxis()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays with the chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             QChart::ChartType QChart::chartType() const
             {
                 return d_ptr->m_type;
             }
             /*!
                 Returns the the rectangle within which the drawing of the chart is done.
                 It does not include the area defined by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
             /*!
                 Sets the \a brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundPen(), plotAreaBackgroundBrush()
              */
             void QChart::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundBrush(brush);
             }
             /*!
                 Returns the brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundPen(), setPlotAreaBackgroundBrush()
              */
             QBrush QChart::plotAreaBackgroundBrush() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundBrush();
             }
             /*!
                 Sets the \a pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundBrush(), plotAreaBackgroundPen()
              */
             void QChart::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundPen(pen);
             }
             /*!
                 Returns the pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundBrush(), setPlotAreaBackgroundPen()
              */
             QPen QChart::plotAreaBackgroundPen() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundPen();
             }
             void QChart::setPlotAreaBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundVisible(visible);
             }
             bool QChart::isPlotAreaBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isPlotAreaBackgroundVisible();
             }
+            void QChart::setLocalizeNumbers(bool localize)
+            {
+                d_ptr->m_presenter->setLocalizeNumbers(localize);
+            }
+            bool QChart::localizeNumbers() const
+            {
+                return d_ptr->m_presenter->localizeNumbers();
+            }
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
                 For polar charts, \a dx indicates the angle along angular axis instead of distance.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->scroll(dx,dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             void QChart::setBackgroundRoundness(qreal diameter)
             {
                 d_ptr->m_presenter->setBackgroundRoundness(diameter);
             }
             qreal QChart::backgroundRoundness() const
             {
                 return d_ptr->m_presenter->backgroundRoundness();
             }
             /*!
               Returns all series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a bottom-aligned horizontal axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any horizontal axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisY(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisX(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Horizontal, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignBottom);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a left-aligned vertical axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any vertical axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisX(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisY(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
               \sa removeAxis(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::addAxis(QAbstractAxis *axis, Qt::Alignment alignment)
             {
                 d_ptr->m_dataset->addAxis(axis, alignment);
             }
             /*!
               Removes the \a axis from the chart.
               The chart releases its ownership of the specified \a axis object.
               \sa addAxis(), createDefaultAxes(), QAbstractSeries::detachAxis()
             */
             void QChart::removeAxis(QAbstractAxis *axis)
             {
                 d_ptr->m_dataset->removeAxis(axis);
             }
             /*!
               Returns the value in the \a series domain that corresponds to the \a position relative to chart widget.
             */
             QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToValue(position, series);
             }
             /*!
               Returns the position on the chart widget that corresponds to the \a value in the \a series domain.
             */
             QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToPosition(value, series);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q, QChart::ChartType type):
                 q_ptr(q),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q)),
                 m_type(type)
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             // Hackish solution to the problem of explicitly assigning the default pen/brush/font
             // to a series or axis and having theme override it:
             // Initialize pens, brushes, and fonts to something nobody is likely to ever use,
             // so that default theme initialization will always set these properly.
             QPen &QChartPrivate::defaultPen()
             {
                 static QPen defaultPen(QColor(1, 2, 0), 0.93247536);
                 return defaultPen;
             }
             QBrush &QChartPrivate::defaultBrush()
             {
                 static QBrush defaultBrush(QColor(1, 2, 0), Qt::Dense7Pattern);
                 return defaultBrush;
             }
             QFont &QChartPrivate::defaultFont()
             {
                 static bool defaultFontInitialized(false);
                 static QFont defaultFont;
                 if (!defaultFontInitialized) {
                     defaultFont.setPointSizeF(8.34563465);
                     defaultFontInitialized = true;
                 }
                 return defaultFont;
             }
             void QChartPrivate::init()
             {
                 m_legend = new LegendScroller(q_ptr);
                 q_ptr->setTheme(QChart::ChartThemeLight);
                 q_ptr->setLayout(m_presenter->layout());
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomReset()
             {
                 m_dataset->zoomResetDomain();
             }
             bool QChartPrivate::isZoomed()
             {
                 return m_dataset->isZoomedDomain();
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +3 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$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             #include <QMargins>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAbstractAxis;
             class QLegend;
             class QChartPrivate;
             class QBoxPlotSeries;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(QChart::ChartTheme theme READ theme WRITE setTheme)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible)
                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(qreal backgroundRoundness READ backgroundRoundness WRITE setBackgroundRoundness)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
                 Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
                 Q_PROPERTY(QChart::ChartType chartType READ chartType)
                 Q_PROPERTY(bool plotAreaBackgroundVisible READ isPlotAreaBackgroundVisible WRITE setPlotAreaBackgroundVisible)
+                Q_PROPERTY(bool localizeNumbers READ localizeNumbers WRITE setLocalizeNumbers)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
                 Q_ENUMS(ChartType)
             public:
                 enum ChartType {
                     ChartTypeUndefined = 0,
                     ChartTypeCartesian,
                     ChartTypePolar
                 };
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy,
                     ChartThemeQt
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 QList<QAbstractSeries *> series() const;
                 // *** deprecated ***
                 void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 QAbstractAxis *axisX(QAbstractSeries *series = 0) const;
                 QAbstractAxis *axisY(QAbstractSeries *series = 0) const;
                 // ******************
                 void addAxis(QAbstractAxis *axis, Qt::Alignment alignment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes(Qt::Orientations orientation = Qt::Horizontal|Qt::Vertical, QAbstractSeries *series = 0) const;
                 void createDefaultAxes();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() 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 setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setDropShadowEnabled(bool enabled = true);
                 bool isDropShadowEnabled() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomOut();
                 void zoomIn(const QRectF &rect);
                 void zoom(qreal factor);
                 void zoomReset();
                 bool isZoomed();
                 void scroll(qreal dx, qreal dy);
                 QLegend *legend() const;
                 void setMinimumMargins(const QMargins& margins);
                 QMargins minimumMargins() const;
                 void setMargins(const QMargins &margins);
                 QMargins margins() const;
                 QRectF plotArea() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setPlotAreaBackgroundVisible(bool visible = true);
                 bool isPlotAreaBackgroundVisible() const;
+                void setLocalizeNumbers(bool localize);
+                bool localizeNumbers() const;
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
                 ChartType chartType() const;
             protected:
                 explicit QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags);
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class DeclarativeChart;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class QAbstractSeries;
                 friend class QBoxPlotSeriesPrivate;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif // QCHART_H

src/xychart/qxyseries.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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
             #include "charthelpers_p.h"
             #include "qchart_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \inmodule Qt Charts
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             #ifdef QDOC_QT5
             /*!
                 \qmltype XYSeries
                 \instantiates QXYSeries
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/xyseries.qdocinc
             */
             #else
             /*!
                 \qmlclass XYSeries QXYSeries
                 \include ../doc/src/xyseries.qdocinc
             */
             #endif
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::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 XYSeries::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 XYSeries::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
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \property QXYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QXYSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa QXYSeries::pointLabelsVisible, QXYSeries::pointLabelsFont, QXYSeries::pointLabelsColor
             */
             /*!
                 \qmlproperty string XYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa QXYSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QXYSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QXYSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty bool XYSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QXYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QXYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with other points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point (\a oldX, \a oldY) with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
                 replace(index, newPoint);
             }
             /*!
               Replaces the point at \a index with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, qreal newX, qreal newY)
             {
                 replace(index, QPointF(newX, newY));
             }
             /*!
               Replaces the point at \a index with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points.
               \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 remove(index);
             }
             /*!
               Removes the point at \a index from the series.
             */
             void QXYSeries::remove(int index)
             {
                 Q_D(QXYSeries);
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             void QXYSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QXYSeries::pointLabelsFormat() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFormat;
             }
             void QXYSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QXYSeries::pointLabelsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsVisible;
             }
             void QXYSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QXYSeries::pointLabelsFont() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFont;
             }
             void QXYSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QXYSeries::pointLabelsColor() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color())
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return new QValueAxis;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new XYAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             void QXYSeriesPrivate::drawSeriesPointLabels(QPainter *painter, const QVector<QPointF> &points,
                                                          const int offset)
             {
                 static const QString xPointTag(QLatin1String("@xPoint"));
                 static const QString yPointTag(QLatin1String("@yPoint"));
                 const int labelOffset = offset + 2;
                 painter->setFont(m_pointLabelsFont);
                 painter->setPen(QPen(m_pointLabelsColor));
                 QFontMetrics fm(painter->font());
                 for (int i(0); i < m_points.size(); i++) {
                     QString pointLabel = m_pointLabelsFormat;
-                    pointLabel.replace(xPointTag, QString::number(m_points.at(i).x()));
+                    pointLabel.replace(xPointTag, presenter()->numberToString(m_points.at(i).x()));
-                    pointLabel.replace(yPointTag, QString::number(m_points.at(i).y()));
+                    pointLabel.replace(yPointTag, presenter()->numberToString(m_points.at(i).y()));
                     // Position text in relation to the point
                     int pointLabelWidth = fm.width(pointLabel);
                     QPointF position(points.at(i));
                     position.setX(position.x() - pointLabelWidth / 2);
                     position.setY(position.y() - labelOffset);
                     painter->drawText(position, pointLabel);
                 }
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages