HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2708:b421e87aa00a

Added QChart::locale property...

Miikka Heikkinen -

r2708:b421e87aa00a

parent child

Context file:

r2708:b421e87aa00a

Collapse all files

plugins/declarative/declarativechart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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}.
+              Defaults to \c{true}.
             */
             /*!
               \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 +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #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();
+                Q_REVISION(4) void 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

src/axis/chartaxiselement.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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;
                     delete labelFormatMatcherLocalized;
                 }
             };
             static StaticLabelFormatMatcherDeleter staticLabelFormatMatcherDeleter;
             ChartAxisElement::ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_animation(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsTextItem(item)),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 m_title->document()->setDocumentMargin(ChartPresenter::textMargin());
                 handleVisibleChanged(axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents, true);
             }
             ChartAxisElement::~ChartAxisElement()
             {
             }
             void ChartAxisElement::connectSlots()
             {
                 QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsPenChanged(const QPen&)), this, SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(titlePenChanged(const QPen&)), this, SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
             }
             void ChartAxisElement::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxisElement::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_labels->setVisible(visible);
             }
             void ChartAxisElement::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxisElement::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsPenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 if (title.isEmpty() || !m_title->isVisible())
                     m_title->setHtml(title);
             }
             void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleTitleFontChanged(const QFont &font)
             {
                 if (m_title->font() != font) {
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxisElement::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if (!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 } else {
                     m_grid->setVisible(axis()->isGridLineVisible());
                     m_arrow->setVisible(axis()->isLineVisible());
                     m_shades->setVisible(axis()->shadesVisible());
                     m_labels->setVisible(axis()->labelsVisible());
                     m_title->setVisible(axis()->isTitleVisible());
                 }
                 if (presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         // We don't want to call invalidate on layout, since it will change minimum size of
                         // component, which we would like to avoid since it causes nasty flips when scrolling
                         // or zooming, instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             bool ChartAxisElement::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             qreal ChartAxisElement::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxisElement::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QString ChartAxisElement::formatLabel(const QString &formatSpec, const QByteArray &array,
                                                   qreal value, int precision, const QString &preStr,
                                                   const QString &postStr) const
             {
                 QString retVal;
                 if (!formatSpec.isEmpty()) {
                     if (formatSpec.at(0) == QLatin1Char('d')
                         || formatSpec.at(0) == QLatin1Char('i')
                         || formatSpec.at(0) == QLatin1Char('c')) {
                         if (presenter()->localizeNumbers())
                             retVal = preStr + presenter()->locale().toString(qint64(value)) + postStr;
                         else
                             retVal = QString().sprintf(array, qint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('u')
                              || formatSpec.at(0) == QLatin1Char('o')
                              || formatSpec.at(0) == QLatin1Char('x')
                              || formatSpec.at(0) == QLatin1Char('X')) {
                         // These formats are not supported by localized numbers
                         retVal = QString().sprintf(array, quint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('f')
                                || formatSpec.at(0) == QLatin1Char('F')
                                || formatSpec.at(0) == QLatin1Char('e')
                                || formatSpec.at(0) == QLatin1Char('E')
                                || formatSpec.at(0) == QLatin1Char('g')
                                || formatSpec.at(0) == QLatin1Char('G')) {
                         if (presenter()->localizeNumbers()) {
                             retVal = preStr
                                     + presenter()->locale().toString(value, formatSpec.at(0).toLatin1(),
                                                                      precision)
                                     + postStr;
                         } else {
                             retVal = QString().sprintf(array, value);
                         }
                     }
                 }
                 return retVal;
             }
             QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks,
                                                             const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 if (format.isNull()) {
                     int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0) + 1;
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
                     int precision = 0;
                     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)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     int n = 0;
                     if (ticks > 1)
                         n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                     n++;
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
                     int precision = 0;
                     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)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
-                    labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
+                    labels << presenter()->locale().toString(QDateTime::fromMSecsSinceEpoch(value), format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/qdatetimeaxis.cpp +2 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 "qdatetimeaxis.h"
             #include "qdatetimeaxis_p.h"
             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
             #include "polarchartdatetimeaxisangular_p.h"
             #include "polarchartdatetimeaxisradial_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <float.h>
             #include <cmath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QDateTimeAxis
                 \inmodule Qt Charts
                 \brief The QDateTimeAxis class is used for manipulating chart's axis.
                 \mainclass
                 The labels can be configured by setting an appropriate DateTime format.
                 QDateTimeAxis works correctly with dates from 4714 BCE to 287396 CE.
                 There are also other limitiation related to QDateTime. Please refer to QDateTime documentation.
                 QDateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Note: QDateTimeAxis is disabled on ARM architecture.
                 \image api_datatime_axis.png
                 QDateTimeAxis can be used with any QXYSeries.
                 To add a data point to the series QDateTime::toMSecsSinceEpoch() is used.
                 \code
                 QLineSeries *series = new QLineSeries;
                 QDateTime xValue;
                 xValue.setDate(QDate(2012, 1 , 18));
                 xValue.setTime(QTime(9, 34));
                 qreal yValue = 12;
                 series->append(xValue.toMSecsSinceEpoch(), yValue);
                 xValue.setDate(QDate(2013, 5 , 11));
                 xValue.setTime(QTime(11, 14));
                 qreal yValue = 22;
                 series->append(xValue.toMSecsSinceEpoch(), yValue);
                 \endcode
                 Adding the series to the chart and setting up the QDateTimeAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 chartView->chart()->addSeries(series);
                 // ...
                 QDateTimeAxis *axisX = new QDateTimeAxis;
                 axisX->setFormat("dd-MM-yyyy h:mm");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             #ifdef QDOC_QT5
             /*!
                 \qmltype DateTimeAxis
                 \instantiates QDateTimeAxis
                 \inqmlmodule QtCommercial.Chart
                 \include doc/src/datetimeaxis.qdocinc
             */
             #else
             /*!
                 \qmlclass DateTimeAxis QDateTimeAxis
                 \include ../doc/src/datetimeaxis.qdocinc
             */
             #endif
             /*!
               \property QDateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty datetime DateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QDateTimeAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty datetime DateTimeAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QDateTimeAxis::minChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal DateTimeAxis::onMinChanged(datetime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::maxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal DateTimeAxis::onMaxChanged(datetime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::rangeChanged(QDateTime min, QDateTime max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QDateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int DateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \property QDateTimeAxis::format
               The format string that is used when creating label for the axis out of a QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
+              \sa QChart::locale
             */
             /*!
               \qmlproperty string DateTimeAxis::format
               The format string that is used when creating label for the axis out of a QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
             */
             /*!
               \fn void QDateTimeAxis::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount number on axis have changed.
             */
             /*!
               \qmlsignal DateTimeAxis::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount number on axis have changed.
             */
             /*!
               \fn void QDateTimeAxis::formatChanged(QString format)
               Axis emits signal when \a format of the axis has changed.
             */
             /*!
               \qmlsignal DateTimeAxis::onFormatChanged(string format)
               Axis emits signal when \a format of the axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QDateTimeAxis::QDateTimeAxis(QObject *parent) :
                 QAbstractAxis(*new QDateTimeAxisPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
             QDateTimeAxis::QDateTimeAxis(QDateTimeAxisPrivate &d, QObject *parent) : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QDateTimeAxis::~QDateTimeAxis()
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             void QDateTimeAxis::setMin(QDateTime min)
             {
                 Q_D(QDateTimeAxis);
                 if (min.isValid())
                     d->setRange(min.toMSecsSinceEpoch(), qMax(d->m_max, qreal(min.toMSecsSinceEpoch())));
             }
             QDateTime QDateTimeAxis::min() const
             {
                 Q_D(const QDateTimeAxis);
                 return QDateTime::fromMSecsSinceEpoch(d->m_min);
             }
             void QDateTimeAxis::setMax(QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (max.isValid())
                     d->setRange(qMin(d->m_min, qreal(max.toMSecsSinceEpoch())), max.toMSecsSinceEpoch());
             }
             QDateTime QDateTimeAxis::max() const
             {
                 Q_D(const QDateTimeAxis);
                 return QDateTime::fromMSecsSinceEpoch(d->m_max);
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QDateTimeAxis::setRange(QDateTime min, QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (!min.isValid() || !max.isValid() || min > max)
                     return;
                 d->setRange(min.toMSecsSinceEpoch(),max.toMSecsSinceEpoch());
             }
             void QDateTimeAxis::setFormat(QString format)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_format != format) {
                     d->m_format = format;
                     emit formatChanged(format);
                 }
             }
             QString QDateTimeAxis::format() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_format;
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QDateTimeAxis::setTickCount(int count)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                    emit tickCountChanged(count);
                 }
             }
             /*!
               \fn int QDateTimeAxis::tickCount() const
               Return number of ticks on the axis.
             */
             int QDateTimeAxis::tickCount() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_tickCount;
             }
             /*!
               Returns the type of the axis.
             */
             QAbstractAxis::AxisType QDateTimeAxis::type() const
             {
                 return AxisTypeDateTime;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5)
             {
                 m_format = "dd-MM-yyyy\nh:mm";
             }
             QDateTimeAxisPrivate::~QDateTimeAxisPrivate()
             {
             }
             void QDateTimeAxisPrivate::setRange(qreal min,qreal max)
             {
                 Q_Q(QDateTimeAxis);
                 bool changed = false;
                 if (m_min != min) {
                     m_min = min;
                     changed = true;
                     emit q->minChanged(QDateTime::fromMSecsSinceEpoch(min));
                 }
                 if (m_max != max) {
                     m_max = max;
                     changed = true;
                     emit q->maxChanged(QDateTime::fromMSecsSinceEpoch(max));
                 }
                 if (changed) {
                     emit q->rangeChanged(QDateTime::fromMSecsSinceEpoch(min), QDateTime::fromMSecsSinceEpoch(max));
                     emit rangeChanged(m_min,m_max);
                 }
             }
             void QDateTimeAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime))
                     q->setMin(min.toDateTime());
             }
             void QDateTimeAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (max.canConvert(QVariant::DateTime))
                     q->setMax(max.toDateTime());
             }
             void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime) && max.canConvert(QVariant::DateTime))
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
             void QDateTimeAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QDateTimeAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartDateTimeAxisY(q,parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new ChartDateTimeAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartDateTimeAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartDateTimeAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QDateTimeAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (m_max == m_min) {
                     if (orientation() == Qt::Vertical)
                         setRange(domain->minY(), domain->maxY());
                     else
                         setRange(domain->minX(), domain->maxX());
                 } else {
                     if (orientation() == Qt::Vertical)
                         domain->setRangeY(m_min, m_max);
                     else
                         domain->setRangeX(m_min, m_max);
                 }
             }
             #include "moc_qdatetimeaxis.cpp"
             #include "moc_qdatetimeaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

src/chartpresenter_p.h +3 -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$
             **
             ****************************************************************************/
             //  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;
+                inline bool localizeNumbers() const { return m_localizeNumbers; }
+                void setLocale(const QLocale &locale);
+                inline const QLocale &locale() const { return m_locale; }
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle,
                                              qreal maxWidth, qreal maxHeight, QRectF &boundingRect);
                 inline static qreal textMargin() { return qreal(0.5); }
                 QString numberToString(double value, char f = 'g', int prec = 6);
-                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/qchart.cpp +27 -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 "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.
+              localized using the QLocale set with the locale property.
               When \c{false}, the "C" locale is always used.
-              Defaults to \c{false}.
+              Defaults to \c{true}.
+              \note This property doesn't affect QDateTimeAxis labels, which always use the QLocale set with
+              the locale property.
+              \sa locale
+            */
+            /*!
+              \property QChart::locale
+              \since QtCharts 2.0
+              Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
+              This also determines the locale used to format QDateTimeAxis labels regardless of
+              localizeNumbers property.
+              Defaults to application default locale at the time the chart is constructed.
+              \sa localizeNumbers
             */
             /*!
              \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::setLocale(const QLocale &locale)
+            {
+                d_ptr->m_presenter->setLocale(locale);
+            }
+            QLocale QChart::locale() const
+            {
+                return d_ptr->m_presenter->locale();
+            }
             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_PROPERTY(QLocale locale READ locale WRITE setLocale)
                 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;
+                void setLocale(const QLocale &locale);
+                QLocale locale() 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

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