HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2861:21c113d296ef

No longer automatically disable QDateTimeAxis on ARM platforms...

Miikka Heikkinen -

r2861:21c113d296ef

parent child

Context file:

r2861:21c113d296ef

Collapse all files

examples/charts/charts.pro +1 -1

             TEMPLATE = subdirs
             SUBDIRS += areachart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
                        modeldata \
                        barchart \
                        boxplotchart \
                        legend \
                        barmodelmapper \
                        lineandbar \
                        horizontalbarchart \
                        horizontalstackedbarchart \
                        horizontalpercentbarchart \
                        donutbreakdown \
                        temperaturerecords \
                        donutchart \
                        multiaxis \
                        legendmarkers \
                        logvalueaxis \
                        polarchart \
                        piechartcustomization \
                        dynamicspline \
                        nesteddonuts \
                        chartinteractions \
                        callout \
                        chartthemes
             qtHaveModule(quick) {
                 SUBDIRS += qmlboxplot \
                        qmlpiechart \
                        qmlweather \
                        qmlf1legends \
                        qmlcustomizations \
                        qmlaxes \
                        qmlcustomlegend \
                        qmlpolarchart \
                        qmlchart \
                        qmloscilloscope
             }
             qtHaveModule(multimedia) {
                 SUBDIRS += audio
             } else {
                 message("QtMultimedia library not available. Some examples are disabled.")
             }
             contains(QT_CONFIG, opengl) {
                 SUBDIRS += openglseries
             } else {
                 message("OpenGL not available. Some examples are disabled.")
             }
-            !linux-arm*: {
+            !contains(QT_COORD_TYPE, float): {
             SUBDIRS += \
                 datetimeaxis
             }

src/charts/axis/axis.pri +1 -1

             #Subdirectiores are defined here, because qt creator doesn't handle nested include(foo.pri) chains very well.
             INCLUDEPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
                 $$PWD/categoryaxis \
                 $$PWD/logvalueaxis
             DEPENDPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
                 $$PWD/categoryaxis \
                 $$PWD/logvalueaxis
             SOURCES += \
                 $$PWD/chartaxiselement.cpp \
                 $$PWD/cartesianchartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
                 $$PWD/verticalaxis.cpp \
                 $$PWD/horizontalaxis.cpp \
                 $$PWD/valueaxis/chartvalueaxisx.cpp \
                 $$PWD/valueaxis/chartvalueaxisy.cpp \
                 $$PWD/valueaxis/qvalueaxis.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy.cpp \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisx.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisy.cpp \
                 $$PWD/categoryaxis/qcategoryaxis.cpp \
                 $$PWD/logvalueaxis/chartlogvalueaxisx.cpp \
                 $$PWD/logvalueaxis/chartlogvalueaxisy.cpp \
                 $$PWD/logvalueaxis/qlogvalueaxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxiselement_p.h \
                 $$PWD/cartesianchartaxis_p.h \
                 $$PWD/qabstractaxis_p.h \
                 $$PWD/verticalaxis_p.h \
                 $$PWD/horizontalaxis_p.h \
                 $$PWD/linearrowitem_p.h \
                 $$PWD/valueaxis/chartvalueaxisx_p.h \
                 $$PWD/valueaxis/chartvalueaxisy_p.h \
                 $$PWD/valueaxis/qvalueaxis_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy_p.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisx_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisy_p.h \
                 $$PWD/categoryaxis/qcategoryaxis_p.h \
                 $$PWD/logvalueaxis/chartlogvalueaxisx_p.h \
                 $$PWD/logvalueaxis/chartlogvalueaxisy_p.h \
                 $$PWD/logvalueaxis/qlogvalueaxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qabstractaxis.h \
                 $$PWD/valueaxis/qvalueaxis.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.h \
                 $$PWD/categoryaxis/qcategoryaxis.h \
                 $$PWD/logvalueaxis/qlogvalueaxis.h \
             # polar
             SOURCES += \
                 $$PWD/polarchartaxis.cpp \
                 $$PWD/polarchartaxisangular.cpp \
                 $$PWD/polarchartaxisradial.cpp \
                 $$PWD/valueaxis/polarchartvalueaxisangular.cpp \
                 $$PWD/valueaxis/polarchartvalueaxisradial.cpp \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisangular.cpp \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisradial.cpp \
                 $$PWD/categoryaxis/polarchartcategoryaxisangular.cpp \
                 $$PWD/categoryaxis/polarchartcategoryaxisradial.cpp
             PRIVATE_HEADERS += \
                 $$PWD/polarchartaxis_p.h \
                 $$PWD/polarchartaxisangular_p.h \
                 $$PWD/polarchartaxisradial_p.h \
                 $$PWD/valueaxis/polarchartvalueaxisangular_p.h \
                 $$PWD/valueaxis/polarchartvalueaxisradial_p.h \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisangular_p.h \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisradial_p.h \
                 $$PWD/categoryaxis/polarchartcategoryaxisangular_p.h \
                 $$PWD/categoryaxis/polarchartcategoryaxisradial_p.h
-            !linux-arm*: {
+            !contains(QT_COORD_TYPE, float): {
             INCLUDEPATH += \
                 $$PWD/datetimeaxis
             DEPENDPATH += \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisy.cpp \
                 $$PWD/datetimeaxis/qdatetimeaxis.cpp \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisangular.cpp \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisradial.cpp
             PRIVATE_HEADERS += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisy_p.h \
                 $$PWD/datetimeaxis/qdatetimeaxis_p.h \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisangular_p.h \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisradial_p.h
             PUBLIC_HEADERS += \
                 $$PWD/datetimeaxis/qdatetimeaxis.h
             }

src/charts/axis/datetimeaxis/qdatetimeaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QDateTimeAxis>
             #include <private/qdatetimeaxis_p.h>
             #include <private/chartdatetimeaxisx_p.h>
             #include <private/chartdatetimeaxisy_p.h>
             #include <private/polarchartdatetimeaxisangular_p.h>
             #include <private/polarchartdatetimeaxisradial_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QChart>
             #include <float.h>
             #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QDateTimeAxis
                 \inmodule Qt Charts
                 \brief The QDateTimeAxis class is used for manipulating chart's axis.
                 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.
+                Note: QDateTimeAxis is disabled on platforms that define qreal as float.
                 \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
             */
             /*!
                 \qmltype DateTimeAxis
                 \instantiates QDateTimeAxis
                 \inqmlmodule QtCharts
                 \brief The DateTimeAxis element is used for manipulating chart's axes.
                 \inherits AbstractAxis
                 The labels can be configured by setting an appropriate DateTime format.
                 Note that any date before 4714 BCE or after about 1.4 million CE may not be accurately stored.
                 DateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
               \property QDateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty 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 = QStringLiteral("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"
             QT_CHARTS_END_NAMESPACE

src/charts/chartdataset.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <private/chartdataset_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <private/qvalueaxis_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QPieSeries>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xypolardomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             #include <private/xlogypolardomain_p.h>
             #include <private/logxypolardomain_p.h>
             #include <private/logxlogypolardomain_p.h>
             #include <private/glxyseriesdata_p.h>
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
             #include <QtCharts/QDateTimeAxis>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
                   m_chart(chart),
                   m_glXYSeriesDataManager(new GLXYSeriesDataManager(this))
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 deleteAllSeries();
                 deleteAllAxes();
             }
             /*
              * This method adds series to chartdataset, series ownership is taken from caller.
              */
             void ChartDataSet::addSeries(QAbstractSeries *series)
             {
                 if (m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not add series. Series already on the chart.");
                     return;
                 }
                 // Ignore unsupported series added to polar chart
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) {
                     if (!(series->type() == QAbstractSeries::SeriesTypeArea
                         || series->type() == QAbstractSeries::SeriesTypeLine
                         || series->type() == QAbstractSeries::SeriesTypeScatter
                         || series->type() == QAbstractSeries::SeriesTypeSpline)) {
                         qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart.");
                         return;
                     }
                     // Disable OpenGL for series in polar charts
                     series->setUseOpenGL(false);
                     series->d_ptr->setDomain(new XYPolarDomain());
                     // Set the correct domain for upper and lower series too
                     if (series->type() == QAbstractSeries::SeriesTypeArea) {
                         foreach (QObject *child, series->children()) {
                             if (qobject_cast<QAbstractSeries *>(child)) {
                                 QAbstractSeries *childSeries = qobject_cast<QAbstractSeries *>(child);
                                 childSeries->d_ptr->setDomain(new XYPolarDomain());
                             }
                         }
                     }
                 } else {
                     series->d_ptr->setDomain(new XYDomain());
                 }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = m_chart;
                 emit seriesAdded(series);
             }
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
             void ChartDataSet::addAxis(QAbstractAxis *axis, Qt::Alignment aligment)
             {
                 if (m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
                     return;
                 }
                 axis->d_ptr->setAlignment(aligment);
                 if (!axis->alignment()) {
                     qWarning() << QObject::tr("No alignment specified !");
                     return;
                 };
                 AbstractDomain *newDomain;
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar)
                     newDomain = new XYPolarDomain();
                 else
                     newDomain = new XYDomain();
                 QSharedPointer<AbstractDomain> domain(newDomain);
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 axis->d_ptr->m_chart = m_chart;
                 m_axisList.append(axis);
                 emit axisAdded(axis);
             }
             /*
              * This method removes series form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (! m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
                     return;
                 }
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     detachAxis(series,axis);
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 // Reset domain to default
                 series->d_ptr->setDomain(new XYDomain());
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 QXYSeries *xySeries = qobject_cast<QXYSeries *>(series);
                 if (xySeries)
                     m_glXYSeriesDataManager->removeSeries(xySeries);
             }
             /*
              * This method removes axis form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (! m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
                     return;
                 }
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                   detachAxis(s,axis);
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
             }
             /*
              * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 if (!series)
                     return false;
                 QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis *> attachedAxisList = series->d_ptr->m_axes;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 if (attachedSeriesList.contains(series)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 AbstractDomain *domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
                 if (type == AbstractDomain::UndefinedDomain) return false;
                 if (domain->type() != type) {
                     AbstractDomain *old = domain;
                     domain = createDomain(type);
                     domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY());
                     // Initialize domain size to old domain size, as it won't get updated
                     // unless geometry changes.
                     domain->setSize(old->size());
                 }
                 if (!domain)
                     return false;
                 if (!domain->attachAxis(axis))
                     return false;
                 QList<AbstractDomain *> blockedDomains;
                 domain->blockRangeSignals(true);
                 blockedDomains << domain;
                 if (domain != series->d_ptr->domain()) {
                     foreach (QAbstractAxis *axis, series->d_ptr->m_axes) {
                         series->d_ptr->domain()->detachAxis(axis);
                         domain->attachAxis(axis);
                         foreach (QAbstractSeries *otherSeries, axis->d_ptr->m_series) {
                             if (otherSeries != series && otherSeries->d_ptr->domain()) {
                                 if (!otherSeries->d_ptr->domain()->rangeSignalsBlocked()) {
                                     otherSeries->d_ptr->domain()->blockRangeSignals(true);
                                     blockedDomains << otherSeries->d_ptr->domain();
                                 }
                             }
                         }
                     }
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
                 foreach (AbstractDomain *blockedDomain, blockedDomains)
                     blockedDomain->blockRangeSignals(false);
                 return true;
             }
             /*
              * This method detaches axis to series, return true if success.
              */
             bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 AbstractDomain* domain =  series->d_ptr->domain();
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (!attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis not attached to series.");
                     return false;
                 }
                 Q_ASSERT(axis->d_ptr->m_series.contains(series));
                 domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 deleteAllAxes();
                 Q_ASSERT(m_axisList.isEmpty());
                 // Select the required axis x and axis y types based on the types of the current series
                 foreach(QAbstractSeries* s, m_seriesList) {
                     typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal);
                     typeY |= s->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QAbstractAxis *axis = 0;
                 //decide what axis should be created
                 switch (type) {
                     case QAbstractAxis::AxisTypeValue:
                     axis = new QValueAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeBarCategory:
                     axis = new QBarCategoryAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategory:
                     axis = new QCategoryAxis(this);
                     break;
-            #ifndef Q_WS_QWS
+            #ifndef QT_QREAL_IS_FLOAT
                     case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
             #endif
                     default:
                     axis = 0;
                     break;
                 }
                 if (axis) {
                     //create one axis for all
                     addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                     qreal min = 0;
                     qreal max = 0;
                     findMinMaxForSeries(m_seriesList,orientation,min,max);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                     axis->setRange(min,max);
                 } else {
                     // Create separate axis for each series
                     foreach(QAbstractSeries *s, m_seriesList) {
                         QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
                         if(axis) {
                             addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                             attachAxis(s,axis);
                         }
                     }
                 }
             }
             void ChartDataSet::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max)
             {
                 Q_ASSERT(!series.isEmpty());
                 AbstractDomain *domain = series.first()->d_ptr->domain();
                 min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                 max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                 for (int i = 1; i< series.size(); i++) {
                     AbstractDomain *domain = series[i]->d_ptr->domain();
                     min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min);
                     max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max);
                 }
                 if (min == max) {
                     min -= 0.5;
                     max += 0.5;
                 }
             }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     s->deleteLater();
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     a->deleteLater();
                 }
                 Q_ASSERT(m_axisList.count() == 0);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomResetDomain()
             {
                 QList<AbstractDomain*> domains;
                 foreach (QAbstractSeries *s, m_seriesList) {
                     AbstractDomain *domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains << domain;
                 }
                 foreach (AbstractDomain *domain, domains)
                     domain->zoomReset();
                 foreach (AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             bool ChartDataSet::isZoomedDomain()
             {
                 foreach (QAbstractSeries *s, m_seriesList) {
                     if (s->d_ptr->domain()->isZoomed())
                         return true;
                 }
                 return false;
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 QPointF point;
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return point;
                 if (series && m_seriesList.contains(series))
                     point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
                 return point;
             }
             QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 QPointF point = m_chart->plotArea().topLeft();
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return QPoint(0, 0);
                 bool ok;
                 if (series && m_seriesList.contains(series))
                     point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok);
                 return point;
             }
             QList<QAbstractAxis *> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis *> axes)
             {
                 enum Type {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 // Assume cartesian chart type, unless chart is set
                 QChart::ChartType chartType(QChart::ChartTypeCartesian);
                 if (m_chart)
                     chartType = m_chart->chartType();
                 foreach (QAbstractAxis *axis, axes)
                 {
                     switch (axis->type()) {
                     case QAbstractAxis::AxisTypeLogValue:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= LogType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= LogType;
                         break;
                     case QAbstractAxis::AxisTypeValue:
                     case QAbstractAxis::AxisTypeBarCategory:
                     case QAbstractAxis::AxisTypeCategory:
                     case QAbstractAxis::AxisTypeDateTime:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= ValueType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= ValueType;
                         break;
                     default:
                         qWarning() << "Undefined type";
                         break;
                     }
                 }
                 if (vertical == Undefined)
                     vertical = ValueType;
                 if (horizontal == Undefined)
                     horizontal = ValueType;
                 if (vertical == ValueType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XLogYDomain;
                     if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XLogYPolarDomain;
                 }
                 if (vertical == ValueType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXLogYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXLogYPolarDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
                 switch (type)
                 {
                 case AbstractDomain::LogXLogYDomain:
                     return new LogXLogYDomain();
                 case AbstractDomain::XYDomain:
                     return new XYDomain();
                 case AbstractDomain::XLogYDomain:
                     return new XLogYDomain();
                 case AbstractDomain::LogXYDomain:
                     return new LogXYDomain();
                 case AbstractDomain::XYPolarDomain:
                     return new XYPolarDomain();
                 case AbstractDomain::XLogYPolarDomain:
                     return new XLogYPolarDomain();
                 case AbstractDomain::LogXYPolarDomain:
                     return new LogXYPolarDomain();
                 case AbstractDomain::LogXLogYPolarDomain:
                     return new LogXLogYPolarDomain();
                 default:
                     return 0;
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/charts.pro +2 0

             ############################# BUILD CONFIG ######################################
             TARGET = QtCharts
             message($$QT_CONFIG)
             QT = core gui widgets
             DEFINES += QT_CHARTS_LIBRARY
+            contains(QT_COORD_TYPE, float): DEFINES += QT_QREAL_IS_FLOAT
             # Fix exports in static builds for applications linking charts module
             static: MODULE_DEFINES += QT_CHARTS_STATICLIB
             MODULE_INCNAME = QtCharts
             QMAKE_DOCS = $$PWD/doc/qtcharts.qdocconf
             load(qt_module)
             QMAKE_TARGET_PRODUCT = "Qt Charts (Qt $$QT_VERSION)"
             QMAKE_TARGET_DESCRIPTION = "Charts component for Qt."
             ############################# SOURCES ##########################################
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/chartthememanager.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
                 $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
                 $$PWD/charttitle.cpp \
                 $$PWD/qpolarchart.cpp
             contains(QT_CONFIG, opengl): SOURCES += $$PWD/glwidget.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/chartthememanager_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chartelement_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
                 $$PWD/charttitle_p.h \
                 $$PWD/charthelpers_p.h
             contains(QT_CONFIG, opengl): PRIVATE_HEADERS += $$PWD/glwidget_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h \
                 $$PWD/chartsnamespace.h \
                 $$PWD/qpolarchart.h
             include($$PWD/common.pri)
             include($$PWD/animations/animations.pri)
             include($$PWD/areachart/areachart.pri)
             include($$PWD/axis/axis.pri)
             include($$PWD/domain/domain.pri)
             include($$PWD/barchart/barchart.pri)
             include($$PWD/legend/legend.pri)
             include($$PWD/linechart/linechart.pri)
             include($$PWD/piechart/piechart.pri)
             include($$PWD/scatterchart/scatter.pri)
             include($$PWD/splinechart/splinechart.pri)
             include($$PWD/themes/themes.pri)
             include($$PWD/xychart/xychart.pri)
             include($$PWD/layout/layout.pri)
             include($$PWD/boxplotchart/boxplotchart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             OTHER_FILES += doc/qtcharts.qdocconf \
                            doc/src/* \
                            doc/images/*
             msvc {
                 # Suppress "conversion from 'size_t' to 'int', possible loss of data" warnings in 64bit
                 # builds resulting from usage of str::sort
                 QMAKE_CXXFLAGS_WARN_ON += -wd4267
             }
             win32:!winrt:!wince {
                 # ChartThemeSystem uses Windows native API
                 LIBS += -luser32
             }

src/chartsqml2/chartsqml2.pro +1 0

             TARGET = qtchartsqml2
             QT += qml quick
             QT += charts charts-private
             TARGETPATH = QtCharts
+            contains(QT_COORD_TYPE, float): DEFINES += QT_QREAL_IS_FLOAT
             IMPORT_VERSION = $$MODULE_VERSION
             # Only build qml plugin static if Qt itself is also built static
             !contains(QT_CONFIG, static): CONFIG -= static staticlib
             include($$PWD/designer/designer.pri)
             INCLUDEPATH += ../../include \
                            ../../include/QtCharts \
                            ../charts \
                            ../charts/animations \
                            ../charts/axis \
                            ../charts/domain
             SOURCES += \
                 chartsqml2_plugin.cpp \
                 declarativechart.cpp \
                 declarativexypoint.cpp \
                 declarativexyseries.cpp \
                 declarativelineseries.cpp \
                 declarativesplineseries.cpp \
                 declarativeareaseries.cpp \
                 declarativescatterseries.cpp \
                 declarativepieseries.cpp \
                 declarativebarseries.cpp \
                 declarativecategoryaxis.cpp \
                 declarativemargins.cpp \
                 declarativeaxes.cpp \
                 declarativepolarchart.cpp \
                 declarativeboxplotseries.cpp \
                 declarativechartnode.cpp \
                 declarativerendernode.cpp
             HEADERS += \
                 declarativechart.h \
                 declarativexypoint.h \
                 declarativexyseries.h \
                 declarativelineseries.h \
                 declarativesplineseries.h \
                 declarativeareaseries.h \
                 declarativescatterseries.h \
                 declarativepieseries.h \
                 declarativebarseries.h \
                 declarativecategoryaxis.h \
                 declarativemargins.h \
                 declarativeaxes.h \
                 declarativepolarchart.h \
                 declarativeboxplotseries.h \
                 declarativechartnode.h \
                 declarativerendernode.h
             OTHER_FILES = qmldir
             CONFIG += no_cxx_module
             load(qml_plugin)
             win32 {
                 CONFIG += skip_target_version_ext
                 VERSION = $$MODULE_VERSION
                 QMAKE_TARGET_PRODUCT = "Qt Charts (Qt $$QT_VERSION)"
                 QMAKE_TARGET_DESCRIPTION = "Charts QML plugin for Qt."
             }
             QML_FILES += \
                 $$PWD/plugins.qmltypes

src/chartsqml2/chartsqml2_plugin.cpp +6 -4

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QChart>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include "declarativecategoryaxis.h"
             #include <QtCharts/QBarCategoryAxis>
             #include "declarativechart.h"
             #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativepieseries.h"
             #include "declarativeaxes.h"
             #include <QtCharts/QVXYModelMapper>
             #include <QtCharts/QHXYModelMapper>
             #include <QtCharts/QHPieModelMapper>
             #include <QtCharts/QVPieModelMapper>
             #include <QtCharts/QHBarModelMapper>
             #include <QtCharts/QVBarModelMapper>
             #include "declarativemargins.h"
             #include <QtCharts/QAreaLegendMarker>
             #include <QtCharts/QBarLegendMarker>
             #include <QtCharts/QPieLegendMarker>
             #include <QtCharts/QXYLegendMarker>
             #include <QtCharts/QBoxPlotModelMapper>
             #include <QtCharts/QVBoxPlotModelMapper>
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtCore/QAbstractItemModel>
             #include <QtQml>
             QT_CHARTS_USE_NAMESPACE
             QML_DECLARE_TYPE(QList<QPieSlice *>)
             QML_DECLARE_TYPE(QList<QBarSet *>)
             QML_DECLARE_TYPE(QList<QAbstractAxis *>)
             QML_DECLARE_TYPE(DeclarativeChart)
             QML_DECLARE_TYPE(DeclarativePolarChart)
             QML_DECLARE_TYPE(DeclarativeMargins)
             QML_DECLARE_TYPE(DeclarativeAreaSeries)
             QML_DECLARE_TYPE(DeclarativeBarSeries)
             QML_DECLARE_TYPE(DeclarativeBarSet)
             QML_DECLARE_TYPE(DeclarativeBoxPlotSeries)
             QML_DECLARE_TYPE(DeclarativeBoxSet)
             QML_DECLARE_TYPE(DeclarativeLineSeries)
             QML_DECLARE_TYPE(DeclarativePieSeries)
             QML_DECLARE_TYPE(DeclarativePieSlice)
             QML_DECLARE_TYPE(DeclarativeScatterSeries)
             QML_DECLARE_TYPE(DeclarativeSplineSeries)
             QML_DECLARE_TYPE(QAbstractAxis)
             QML_DECLARE_TYPE(QValueAxis)
             QML_DECLARE_TYPE(QBarCategoryAxis)
             QML_DECLARE_TYPE(QCategoryAxis)
-            QML_DECLARE_TYPE(QDateTimeAxis)
+            #ifndef QT_QREAL_IS_FLOAT
+                QML_DECLARE_TYPE(QDateTimeAxis)
+            #endif
             QML_DECLARE_TYPE(QLogValueAxis)
             QML_DECLARE_TYPE(QLegend)
             QML_DECLARE_TYPE(QLegendMarker)
             QML_DECLARE_TYPE(QAreaLegendMarker)
             QML_DECLARE_TYPE(QBarLegendMarker)
             QML_DECLARE_TYPE(QPieLegendMarker)
             QML_DECLARE_TYPE(QHPieModelMapper)
             QML_DECLARE_TYPE(QHXYModelMapper)
             QML_DECLARE_TYPE(QPieModelMapper)
             QML_DECLARE_TYPE(QHBarModelMapper)
             QML_DECLARE_TYPE(QBarModelMapper)
             QML_DECLARE_TYPE(QVBarModelMapper)
             QML_DECLARE_TYPE(QVPieModelMapper)
             QML_DECLARE_TYPE(QVXYModelMapper)
             QML_DECLARE_TYPE(QXYLegendMarker)
             QML_DECLARE_TYPE(QXYModelMapper)
             QML_DECLARE_TYPE(QBoxPlotModelMapper)
             QML_DECLARE_TYPE(QVBoxPlotModelMapper)
             QML_DECLARE_TYPE(QAbstractSeries)
             QML_DECLARE_TYPE(QXYSeries)
             QML_DECLARE_TYPE(QAbstractBarSeries)
             QML_DECLARE_TYPE(QBarSeries)
             QML_DECLARE_TYPE(QBarSet)
             QML_DECLARE_TYPE(QAreaSeries)
             QML_DECLARE_TYPE(QHorizontalBarSeries)
             QML_DECLARE_TYPE(QHorizontalPercentBarSeries)
             QML_DECLARE_TYPE(QHorizontalStackedBarSeries)
             QML_DECLARE_TYPE(QLineSeries)
             QML_DECLARE_TYPE(QPercentBarSeries)
             QML_DECLARE_TYPE(QPieSeries)
             QML_DECLARE_TYPE(QPieSlice)
             QML_DECLARE_TYPE(QScatterSeries)
             QML_DECLARE_TYPE(QSplineSeries)
             QML_DECLARE_TYPE(QStackedBarSeries)
             QT_CHARTS_BEGIN_NAMESPACE
             class QtChartsQml2Plugin : public QQmlExtensionPlugin
             {
                 Q_OBJECT
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCharts"));
                     // @uri QtCharts
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     qRegisterMetaType<QList<QAbstractAxis *> >();
                     // QtCharts 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 1, 0, "DeclarativeAxes",
                                                            QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     // QtCharts 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCharts 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 2>(uri, 1, 2, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 2>(uri, 1, 2, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 2>(uri, 1, 2, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 2>(uri, 1, 2, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 1, 2, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 1, 2, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 1, 2, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
                     // QtCharts 1.3
                     qmlRegisterType<DeclarativeChart, 3>(uri, 1, 3, "ChartView");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
                     qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                     qmlRegisterType<QLogValueAxis>(uri, 1, 3, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries>(uri, 1, 3, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet>(uri, 1, 3, "BoxSet");
                     // QtCharts 1.4
                     qmlRegisterType<DeclarativeAreaSeries, 4>(uri, 1, 4, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSet, 2>(uri, 1, 4, "BarSet");
                     qmlRegisterType<DeclarativeBoxPlotSeries, 1>(uri, 1, 4, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet, 1>(uri, 1, 4, "BoxSet");
                     qmlRegisterType<DeclarativePieSlice>(uri, 1, 4, "PieSlice");
                     qmlRegisterType<DeclarativeScatterSeries, 4>(uri, 1, 4, "ScatterSeries");
                     // QtCharts 2.0
                     qmlRegisterType<QVBoxPlotModelMapper>(uri, 2, 0, "VBoxPlotModelMapper");
                     qmlRegisterUncreatableType<QBoxPlotModelMapper>(uri, 2, 0, "BoxPlotModelMapper",
                         QLatin1String("Trying to create uncreatable: BoxPlotModelMapper."));
                     qmlRegisterType<DeclarativeChart, 4>(uri, 2, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 2, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries, 4>(uri, 2, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 2, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 2, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 4>(uri, 2, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 2, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 2, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 2, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 2, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 2, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet, 2>(uri, 2, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 2, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 2, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 2, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 2, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 2, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 2, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 2, 0, "ValueAxis");
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                     qmlRegisterType<QDateTimeAxis>(uri, 2, 0, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 2, 0, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 2, 0, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 2, 0, "BarCategoryAxis");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 2, 0, "PolarChartView");
                     qmlRegisterType<QLogValueAxis, 1>(uri, 2, 0, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries, 1>(uri, 2, 0, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet, 1>(uri, 2, 0, "BoxSet");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 2, 0, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 2, 0, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 2, 0, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSlice>(uri, 2, 0, "PieSlice");
                     qmlRegisterUncreatableType<QLegend>(uri, 2, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 2, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 2, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 2, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 2, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 2, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 2, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 2, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 2, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 2, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 2, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 2, 0, "DeclarativeAxes",
                                                                 QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 2, 0, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCharts 2.1
                     qmlRegisterType<DeclarativeCategoryAxis, 1>(uri, 2, 1, "CategoryAxis");
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 2, 1, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterType<DeclarativeChart, 5>(uri, 2, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 5>(uri, 2, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 4>(uri, 2, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 4>(uri, 2, 1, "SplineSeries");
                 }
             };
             QT_CHARTS_END_NAMESPACE
             #include "chartsqml2_plugin.moc"
             QT_CHARTS_USE_NAMESPACE

src/chartsqml2/declarativechart.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QtGui/QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
             #include "declarativechartnode.h"
             #include "declarativerendernode.h"
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include "declarativemargins.h"
             #include <private/chartdataset_p.h>
             #include "declarativeaxes.h"
             #include <private/qchart_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QPolarChart>
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtWidgets/QGraphicsSceneHoverEvent>
             #include <QtWidgets/QApplication>
             #include <QtCore/QTimer>
             #include <QtCore/QThread>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCharts
                 \brief Chart element.
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \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 int ChartView::animationDuration
              The duration of the animation for the chart.
              */
             /*!
              \qmlproperty easing ChartView::animationEasingCurve
              The easing curve of the animation for the chart.
             */
             /*!
               \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 circle 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 list<AbstractAxis> ChartView::axes
               The axes of the ChartView.
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \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::margins
             */
             /*!
               \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}.
               \sa locale
             */
             /*!
               \qmlproperty locale ChartView::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 DateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \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 ChartView::setAxisX(AbstractAxis axis, AbstractSeries series)
               Set the x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisY(AbstractAxis axis, AbstractSeries series)
               Set the y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoom(real factor)
               Zooms in by \a factor on the center of the chart.
               A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
             */
             /*!
               \qmlmethod ChartView::zoomIn()
               Zooms in the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomIn(rect rectangle)
               Zooms in the view to a maximum level at which \a rectangle is still fully visible.
               \note This is not supported for polar charts.
             */
             /*!
               \qmlmethod ChartView::zoomOut()
               Zooms out the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomReset()
               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.
             */
             /*!
               \qmlmethod ChartView::isZoomed()
               Returns true if any series has a zoomed domain.
             */
             /*!
               \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.
             */
             /*!
               \qmlmethod point ChartView::mapToValue(point position, AbstractSeries series)
               Returns the value in the \a series domain that corresponds to the \a position relative to the
               chart.
             */
             /*!
               \qmlmethod point ChartView::mapToPosition(point value, AbstractSeries series)
               Returns the position on the chart that corresponds to the \a value in the \a series domain.
             */
             /*!
               \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(QQuickItem *parent)
                 : QQuickItem(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
                 : QQuickItem(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
                 m_sceneImage = 0;
                 m_sceneImageDirty = false;
                 m_sceneImageNeedsClear = false;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
                 setFlag(ItemHasContents, true);
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
                 m_chart->d_ptr->m_presenter->glSetUseWidget(false);
                 m_glXYDataManager = m_chart->d_ptr->m_dataset->glXYSeriesDataManager();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
                 connect(m_scene, &QGraphicsScene::changed, this, &DeclarativeChart::sceneChanged);
                 connect(this, &DeclarativeChart::needRender, this, &DeclarativeChart::renderScene,
                         Qt::QueuedConnection);
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
                 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(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)),
                         this, SLOT(changeMargins(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*)));
                 connect(m_chart, &QChart::plotAreaChanged, this, &DeclarativeChart::plotAreaChanged);
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit marginsChanged();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
                 delete m_sceneImage;
             }
             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);
                     }
                 }
                 QQuickItem::componentComplete();
             }
             void DeclarativeChart::seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                                           Qt::Orientations orientation,
                                                           Qt::Alignment alignment)
             {
                 if (!series->attachedAxes().contains(axis)) {
                     // Remove & delete old axes that are not attached to any other series
                     foreach (QAbstractAxis* oldAxis, m_chart->axes(orientation, series)) {
                         bool otherAttachments = false;
                         if (oldAxis != axis) {
                             foreach (QAbstractSeries *oldSeries, m_chart->series()) {
                                 if (oldSeries != series && oldSeries->attachedAxes().contains(oldAxis)) {
                                     otherAttachments = true;
                                     break;
                                 }
                             }
                             if (!otherAttachments) {
                                 m_chart->removeAxis(oldAxis);
                                 delete oldAxis;
                             }
                         }
                     }
                     if (!m_chart->axes(orientation).contains(axis))
                         m_chart->addAxis(axis, alignment);
                     series->attachAxis(axis);
                 }
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignBottom);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignTop);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignLeft);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignRight);
                 } 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());
                     }
                 }
                 QQuickItem::geometryChanged(newGeometry, oldGeometry);
             }
             QSGNode *DeclarativeChart::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
             {
                 DeclarativeChartNode *node = static_cast<DeclarativeChartNode *>(oldNode);
                 if (!node) {
                     node =  new DeclarativeChartNode(window());
                     connect(window(), &QQuickWindow::beforeRendering,
                             node->glRenderNode(), &DeclarativeRenderNode::render);
                 }
                 const QRectF &bRect = boundingRect();
                 // Update GL data
                 if (m_glXYDataManager->dataMap().size() || m_glXYDataManager->mapDirty()) {
                     const QRectF &plotArea = m_chart->plotArea();
                     const QSizeF &chartAreaSize = m_chart->size();
                     // We can't use chart's plot area directly, as graphicscene has some internal minimum size
                     const qreal normalizedX = plotArea.x() / chartAreaSize.width();
                     const qreal normalizedY = plotArea.y() / chartAreaSize.height();
                     const qreal normalizedWidth = plotArea.width() / chartAreaSize.width();
                     const qreal normalizedHeight = plotArea.height() / chartAreaSize.height();
                     QRectF adjustedPlotArea(normalizedX * bRect.width(),
                                             normalizedY * bRect.height(),
                                             normalizedWidth * bRect.width(),
                                             normalizedHeight * bRect.height());
                     const QSize &adjustedPlotSize = adjustedPlotArea.size().toSize();
                     if (adjustedPlotSize != node->glRenderNode()->textureSize())
                         node->glRenderNode()->setTextureSize(adjustedPlotSize);
                     node->glRenderNode()->setRect(adjustedPlotArea);
                     node->glRenderNode()->setSeriesData(m_glXYDataManager->mapDirty(),
                                                         m_glXYDataManager->dataMap());
                     // Clear dirty flags from original xy data
                     m_glXYDataManager->clearAllDirty();
                 }
                 // Copy chart (if dirty) to chart node
                 if (m_sceneImageDirty) {
                     node->createTextureFromImage(*m_sceneImage);
                     m_sceneImageDirty = false;
                 }
                 node->setRect(bRect);
                 return node;
             }
             void DeclarativeChart::sceneChanged(QList<QRectF> region)
             {
                 const int count = region.size();
                 const qreal limitSize = 0.01;
                 if (count && !m_updatePending) {
                     qreal totalSize = 0.0;
                     for (int i = 0; i < count; i++) {
                         const QRectF &reg = region.at(i);
                         totalSize += (reg.height() * reg.width());
                         if (totalSize >= limitSize)
                             break;
                     }
                     // Ignore region updates that change less than small fraction of a pixel, as there is
                     // little point regenerating the image in these cases. These are typically cases
                     // where OpenGL series are drawn to otherwise static chart.
                     if (totalSize >= limitSize) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
                         emit needRender();
                     } else {
                         // We do want to call update to trigger possible gl series updates.
                         update();
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
                 m_sceneImageDirty = true;
                 QSize chartSize = m_chart->size().toSize();
                 if (!m_sceneImage || chartSize != m_sceneImage->size()) {
                     delete m_sceneImage;
                     m_sceneImage = new QImage(chartSize, QImage::Format_ARGB32);
                     m_sceneImageNeedsClear = true;
                 }
                 if (m_sceneImageNeedsClear) {
                     m_sceneImage->fill(Qt::transparent);
                     // Don't clear the flag if chart background has any transparent element to it
                     if (m_chart->backgroundBrush().color().alpha() == 0xff && !m_chart->isDropShadowEnabled())
                         m_sceneImageNeedsClear = false;
                 }
                 QPainter painter(m_sceneImage);
                 if (antialiasing()) {
                     painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing
                                            | QPainter::SmoothPixmapTransform);
                 }
                 QRect renderRect(QPoint(0, 0), chartSize);
                 m_scene->render(&painter, renderRect, renderRect);
                 update();
             }
             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::mouseDoubleClickEvent(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::GraphicsSceneMouseDoubleClick);
                 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::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             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::setAnimationDuration(int msecs)
             {
                 if (msecs != m_chart->animationDuration()) {
                     m_chart->setAnimationDuration(msecs);
                     emit animationDurationChanged(msecs);
                 }
             }
             int DeclarativeChart::animationDuration() const
             {
                 return m_chart->animationDuration();
             }
             void DeclarativeChart::setAnimationEasingCurve(const QEasingCurve &curve)
             {
                 if (curve != m_chart->animationEasingCurve()) {
                     m_chart->setAnimationEasingCurve(curve);
                     emit animationEasingCurveChanged(curve);
                 }
             }
             QEasingCurve DeclarativeChart::animationEasingCurve() const
             {
                 return m_chart->animationEasingCurve();
             }
             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()) {
                     if (color.alpha() < 0xff)
                         m_sceneImageNeedsClear = true;
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCharts::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 QtCharts::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();
             }
             void QtCharts::DeclarativeChart::setLocale(const QLocale &locale)
             {
                 if (m_chart->locale() != locale) {
                     m_chart->setLocale(locale);
                     emit localeChanged();
                 }
             }
             QLocale QtCharts::DeclarativeChart::locale() const
             {
                 return m_chart->locale();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_sceneImageNeedsClear = true;
                     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_sceneImageNeedsClear = true;
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void DeclarativeChart::zoomIn(const QRectF &rectangle)
             {
                 m_chart->zoomIn(rectangle);
             }
             void DeclarativeChart::zoomOut()
             {
                 m_chart->zoomOut();
             }
             void DeclarativeChart::zoomReset()
             {
                 m_chart->zoomReset();
             }
             bool DeclarativeChart::isZoomed()
             {
                 return m_chart->isZoomed();
             }
             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);
             }
             QQmlListProperty<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QQmlListProperty<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             }
             void DeclarativeChart::axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QQmlListProperty<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(QQmlListProperty<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(QQmlListProperty<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();
                     DeclarativeLineSeries *line = new DeclarativeLineSeries();
                     line->setParent(area);
                     area->setUpperSeries(line);
                     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 || !axisY)
                         initializeAxes(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, 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 && series)
                     seriesAxisAttachHelper(series, axis, Qt::Horizontal, Qt::AlignBottom);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Vertical, Qt::AlignLeft);
             }
             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
+            #ifndef QT_QREAL_IS_FLOAT
                 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)
             {
                 qreal min;
                 qreal max;
                 // Initialize axis X
                 if (axes->axisX()) {
                     axes->emitAxisXChanged();
                 } else if (axes->axisXTop()) {
                     axes->emitAxisXTopChanged();
                 } else {
                     axes->setAxisX(defaultAxis(Qt::Horizontal, series));
                     findMinMaxForSeries(series, Qt::Horizontal, min, max);
                     axes->axisX()->setRange(min, max);
                 }
                 // Initialize axis Y
                 if (axes->axisY()) {
                     axes->emitAxisYChanged();
                 } else if (axes->axisYRight()) {
                     axes->emitAxisYRightChanged();
                 } else {
                     axes->setAxisY(defaultAxis(Qt::Vertical, series));
                     findMinMaxForSeries(series, Qt::Vertical, min, max);
                     axes->axisY()->setRange(min, max);
                 }
             }
             void DeclarativeChart::findMinMaxForSeries(QAbstractSeries *series, Qt::Orientations orientation,
                                                        qreal &min, qreal &max)
             {
                 if (!series) {
                     min = 0.5;
                     max = 0.5;
                 } else {
                     AbstractDomain *domain = series->d_ptr->domain();
                     min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                     max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                     if (min == max) {
                         min -= 0.5;
                         max += 0.5;
                     }
                 }
             }
             QPointF DeclarativeChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return m_chart->mapToValue(position, series);
             }
             QPointF DeclarativeChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return m_chart->mapToPosition(value, series);
             }
             #include "moc_declarativechart.cpp"
             QT_CHARTS_END_NAMESPACE

tests/auto/auto.pro +1 -1

             TEMPLATE = subdirs
             SUBDIRS += \
                        qchartview \
                        qchart \
                        qlineseries \
                        qbarset \
                        qbarseries \
                        qstackedbarseries \
                        qpercentbarseries \
                        qpieslice qpieseries \
                        qpiemodelmapper \
                        qsplineseries \
                        qscatterseries \
                        qxymodelmapper \
                        qbarmodelmapper \
                        qhorizontalbarseries \
                        qhorizontalstackedbarseries \
                        qhorizontalpercentbarseries \
                        qvalueaxis \
                        qlogvalueaxis \
                        qcategoryaxis \
                        qbarcategoryaxis \
                        domain \
                        chartdataset \
                        qlegend \
                        cmake
-            !linux-arm*: {
+            !contains(QT_COORD_TYPE, float): {
                 SUBDIRS += \
                        qdatetimeaxis
             }
             qtHaveModule(quick) {
                 SUBDIRS += qml \
                            qml-qtquicktest
             }
             !contains(QT_CONFIG, private_tests): SUBDIRS -= \
                 domain \
                 chartdataset

tests/auto/chartdataset/chartdataset.pro +1 0

             !include( ../auto.pri ) {
                 error( "Couldn't find the auto.pri file!" )
             }
             QT += charts-private
+            contains(QT_COORD_TYPE, float): DEFINES += QT_QREAL_IS_FLOAT
             SOURCES += tst_chartdataset.cpp

tests/auto/chartdataset/tst_chartdataset.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QCategoryAxis>
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
             #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <private/chartdataset_p.h>
             #include <private/abstractdomain_p.h>
             #include <tst_definitions.h>
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(AbstractDomain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(Qt::Alignment)
             Q_DECLARE_METATYPE(QList<Qt::Alignment>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public:
                 tst_ChartDataSet():m_dataset(0){};
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void chartdataset_data();
                 void chartdataset();
                 void addSeries_data();
                 void addSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void addAxis_data();
                 void addAxis();
                 void removeAxis_data();
                 void removeAxis();
                 void attachAxis_data();
                 void attachAxis();
                 void detachAxis_data();
                 void detachAxis();
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<AbstractDomain*>();
                 qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_ChartDataSet::init()
             {
                 Q_ASSERT(!m_dataset);
                 m_dataset = new ChartDataSet(0);
             }
             void tst_ChartDataSet::cleanup()
             {
                 delete m_dataset;
                 m_dataset = 0;
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axes().isEmpty());
             	QVERIFY(m_dataset->series().isEmpty());
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QTest::newRow("line") << line;
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(new QLineSeries(this)));
                 QTest::newRow("area") << area;
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QTest::newRow("scatter") << scatter;
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QTest::newRow("spline") << spline;
                 QAbstractSeries* pie = new QPieSeries(this);
                 QTest::newRow("pie") << pie;
                 QAbstractSeries* bar = new QBarSeries(this);
                 QTest::newRow("bar") << bar;
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QTest::newRow("percent") << percent;
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addSeries(series);
                 QCOMPARE(m_dataset->series().count(),1);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addSeries(series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeSeries(series);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
                 delete series;
             }
             void tst_ChartDataSet::addAxis_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QAbstractAxis* value = new QValueAxis(this);
                 QAbstractAxis* category = new QCategoryAxis(this);
                 QAbstractAxis* barcategory = new QBarCategoryAxis(this);
-            #ifndef Q_WS_QWS
+            #ifndef QT_QREAL_IS_FLOAT
                 QAbstractAxis* datetime = new QDateTimeAxis(this);
             #endif
                 QTest::newRow("value") << value;
                 QTest::newRow("category") << category;
                 QTest::newRow("barcategory") << barcategory;
-            #ifndef Q_WS_QWS
+            #ifndef QT_QREAL_IS_FLOAT
                 QTest::newRow("datetime") << datetime;
             #endif
             }
             void tst_ChartDataSet::addAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->axes().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QCOMPARE(m_dataset->axes().count(),1);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeAxis_data()
             {
                 addAxis_data();
             }
             void tst_ChartDataSet::removeAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeAxis(axis);
                 QCOMPARE(m_dataset->axes().count(),0);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 delete axis;
             }
             void tst_ChartDataSet::attachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QList<Qt::Alignment> >("alignment");
                 QTest::addColumn<QAbstractSeries*>("attachSeries");
                 QTest::addColumn<QAbstractAxis*>("attachAxis");
                 QTest::addColumn<bool>("success");
                 {
                  QList<QAbstractSeries*> series;
                  QList<QAbstractAxis*> axes;
                  QList<Qt::Alignment> alignment;
                  QAbstractSeries* line = new QLineSeries(this);
                  QAbstractAxis* value1 = new QValueAxis(this);
                  QAbstractAxis* value2 = new QValueAxis(this);
                  series << line << 0;
                  axes << value1 << value2;
                  alignment << Qt::AlignBottom << Qt::AlignLeft;
                  QTest::newRow("first") << series << axes << alignment << line << value2 << true ;
                 }
                 {
                   QList<QAbstractSeries*> series;
                   QList<QAbstractAxis*> axes;
                   QList<Qt::Alignment> alignment;
                   QAbstractSeries* line = new QLineSeries(this);
                   QAbstractAxis* value1 = new QValueAxis(this);
                   QAbstractAxis* value2 = new QValueAxis(this);
                   series << 0 << line;
                   axes << value1 << value2;
                   alignment << Qt::AlignBottom << Qt::AlignLeft;
                   QTest::newRow("second") << series << axes << alignment << line << value1 << true;
                 }
             }
             void tst_ChartDataSet::attachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QList<Qt::Alignment>, alignment);
                 QFETCH(QAbstractSeries*, attachSeries);
                 QFETCH(QAbstractAxis*, attachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 Q_ASSERT(series.count() == alignment.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0 ; i < series.count() ; i++){
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],alignment[i]);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->attachAxis(attachSeries,attachAxis),success);
             }
             void tst_ChartDataSet::detachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QAbstractSeries*>("detachSeries");
                 QTest::addColumn<QAbstractAxis*>("detachAxis");
                 QTest::addColumn<bool>("success");
                 {
                 QList<QAbstractSeries*> series;
                 QList<QAbstractAxis*> axes;
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractAxis* value = new QValueAxis(this);
                 series << line;
                 axes << value;
                 QTest::newRow("first") << series << axes << line << value << true;
                 }
             }
             void tst_ChartDataSet::detachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QAbstractSeries*, detachSeries);
                 QFETCH(QAbstractAxis*, detachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0; i < series.count(); i++) {
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],Qt::AlignBottom);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->detachAxis(detachSeries,detachAxis),success);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

tests/auto/qml/qml.pro +1 0

             !include( ../auto.pri ) {
                 error( "Couldn't find the auto.pri file!" )
             }
             SOURCES += tst_qml.cpp
             QT += qml quick
+            contains(QT_COORD_TYPE, float): DEFINES += QT_QREAL_IS_FLOAT

tests/auto/qml/tst_qml.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtQml/QQmlEngine>
             #include <QtQml/QQmlComponent>
             #include "tst_definitions.h"
             class tst_qml : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void checkPlugin_data();
                 void checkPlugin();
             private:
                 QString componentErrors(const QQmlComponent* component) const;
                 QString imports_1_1();
                 QString imports_1_3();
                 QString imports_1_4();
                 QString imports_2_0();
                 QString imports_2_1();
             };
             QString tst_qml::componentErrors(const QQmlComponent* component) const
             {
                 Q_ASSERT(component);
                 QStringList errors;
                 foreach (QQmlError const& error, component->errors()) {
                     errors  << error.toString();
                 }
                 return errors.join("\n");
             }
             QString tst_qml::imports_1_1()
             {
                 return "import QtQuick 2.0 \n"
                        "import QtCharts 1.1 \n";
             }
             QString tst_qml::imports_1_3()
             {
                 return "import QtQuick 2.0 \n"
                        "import QtCharts 1.3 \n";
             }
             QString tst_qml::imports_1_4()
             {
                 return "import QtQuick 2.0 \n"
                        "import QtCharts 1.4 \n";
             }
             QString tst_qml::imports_2_0()
             {
                 return "import QtQuick 2.0 \n"
                        "import QtCharts 2.0 \n";
             }
             QString tst_qml::imports_2_1()
             {
                 return "import QtQuick 2.1 \n"
                        "import QtCharts 2.1 \n";
             }
             void tst_qml::initTestCase()
             {
             }
             void tst_qml::cleanupTestCase()
             {
             }
             void tst_qml::init()
             {
             }
             void tst_qml::cleanup()
             {
             }
             void tst_qml::checkPlugin_data()
             {
                 QTest::addColumn<QString>("source");
                 QTest::newRow("createChartView") <<  imports_1_1() + "ChartView{}";
                 QTest::newRow("XYPoint") << imports_1_1() + "XYPoint{}";
                 QTest::newRow("scatterSeries") <<  imports_1_1() + "ScatterSeries{}";
                 QTest::newRow("lineSeries") <<  imports_1_1() + "LineSeries{}";
                 QTest::newRow("splineSeries") <<  imports_1_1() + "SplineSeries{}";
                 QTest::newRow("areaSeries") <<  imports_1_1() + "AreaSeries{}";
                 QTest::newRow("barSeries") << imports_1_1() + "BarSeries{}";
                 QTest::newRow("stackedBarSeries") << imports_1_1() + "StackedBarSeries{}";
                 QTest::newRow("precentBarSeries") << imports_1_1() + "PercentBarSeries{}";
                 QTest::newRow("horizonatlBarSeries") << imports_1_1() + "HorizontalBarSeries{}";
                 QTest::newRow("horizonatlStackedBarSeries") << imports_1_1() + "HorizontalStackedBarSeries{}";
                 QTest::newRow("horizonatlstackedBarSeries") << imports_1_1() + "HorizontalPercentBarSeries{}";
                 QTest::newRow("pieSeries") << imports_1_1() + "PieSeries{}";
                 QTest::newRow("PieSlice") << imports_1_1() + "PieSlice{}";
                 QTest::newRow("BarSet") << imports_1_1() + "BarSet{}";
                 QTest::newRow("HXYModelMapper") << imports_1_1() + "HXYModelMapper{}";
                 QTest::newRow("VXYModelMapper") << imports_1_1() + "VXYModelMapper{}";
                 QTest::newRow("HPieModelMapper") << imports_1_1() + "HPieModelMapper{}";
                 QTest::newRow("HPieModelMapper") << imports_1_1() + "HPieModelMapper{}";
                 QTest::newRow("HBarModelMapper") << imports_1_1() + "HBarModelMapper{}";
                 QTest::newRow("VBarModelMapper") << imports_1_1() + "VBarModelMapper{}";
                 QTest::newRow("ValueAxis") << imports_1_1() + "ValueAxis{}";
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                 QTest::newRow("DateTimeAxis") << imports_1_1() + "DateTimeAxis{}";
             #endif
                 QTest::newRow("CategoryAxis") << imports_1_1() + "CategoryAxis{}";
                 QTest::newRow("CategoryRange") << imports_1_1() + "CategoryRange{}";
                 QTest::newRow("BarCategoryAxis") << imports_1_1() + "BarCategoryAxis{}";
                 QTest::newRow("createPolarChartView") <<  imports_1_3() + "PolarChartView{}";
                 QTest::newRow("LogValueAxis") <<  imports_1_3() + "LogValueAxis{}";
                 QTest::newRow("BoxPlotSeries") <<  imports_1_3() + "BoxPlotSeries{}";
                 QTest::newRow("BoxSet") <<  imports_1_3() + "BoxSet{}";
                 QTest::newRow("createChartView_2_0") <<  imports_2_0() + "ChartView{}";
                 QTest::newRow("XYPoint_2_0") << imports_2_0() + "XYPoint{}";
                 QTest::newRow("scatterSeries_2_0") <<  imports_2_0() + "ScatterSeries{}";
                 QTest::newRow("lineSeries_2_0") <<  imports_2_0() + "LineSeries{}";
                 QTest::newRow("splineSeries_2_0") <<  imports_2_0() + "SplineSeries{}";
                 QTest::newRow("areaSeries_2_0") <<  imports_2_0() + "AreaSeries{}";
                 QTest::newRow("barSeries_2_0") << imports_2_0() + "BarSeries{}";
                 QTest::newRow("stackedBarSeries_2_0") << imports_2_0() + "StackedBarSeries{}";
                 QTest::newRow("precentBarSeries_2_0") << imports_2_0() + "PercentBarSeries{}";
                 QTest::newRow("horizonatlBarSeries_2_0") << imports_2_0() + "HorizontalBarSeries{}";
                 QTest::newRow("horizonatlStackedBarSeries_2_0")
                         << imports_2_0() + "HorizontalStackedBarSeries{}";
                 QTest::newRow("horizonatlstackedBarSeries_2_0")
                         << imports_2_0() + "HorizontalPercentBarSeries{}";
                 QTest::newRow("pieSeries_2_0") << imports_2_0() + "PieSeries{}";
                 QTest::newRow("PieSlice_2_0") << imports_2_0() + "PieSlice{}";
                 QTest::newRow("BarSet_2_0") << imports_2_0() + "BarSet{}";
                 QTest::newRow("HXYModelMapper_2_0") << imports_2_0() + "HXYModelMapper{}";
                 QTest::newRow("VXYModelMapper_2_0") << imports_2_0() + "VXYModelMapper{}";
                 QTest::newRow("HPieModelMapper_2_0") << imports_2_0() + "HPieModelMapper{}";
                 QTest::newRow("HPieModelMapper_2_0") << imports_2_0() + "HPieModelMapper{}";
                 QTest::newRow("HBarModelMapper_2_0") << imports_2_0() + "HBarModelMapper{}";
                 QTest::newRow("VBarModelMapper_2_0") << imports_2_0() + "VBarModelMapper{}";
                 QTest::newRow("ValueAxis_2_0") << imports_2_0() + "ValueAxis{}";
-            #ifndef QT_ON_ARM
+            #ifndef QT_QREAL_IS_FLOAT
                 QTest::newRow("DateTimeAxis_2_0") << imports_2_0() + "DateTimeAxis{}";
             #endif
                 QTest::newRow("CategoryAxis_2_0") << imports_2_0() + "CategoryAxis{}";
                 QTest::newRow("CategoryRange_2_0") << imports_2_0() + "CategoryRange{}";
                 QTest::newRow("BarCategoryAxis_2_0") << imports_2_0() + "BarCategoryAxis{}";
                 QTest::newRow("createPolarChartView_2_0") <<  imports_2_0() + "PolarChartView{}";
                 QTest::newRow("LogValueAxis_2_0") <<  imports_2_0() + "LogValueAxis{}";
                 QTest::newRow("BoxPlotSeries_2_0") <<  imports_2_0() + "BoxPlotSeries{}";
                 QTest::newRow("BoxSet_2_0") <<  imports_2_0() + "BoxSet{}";
                 QTest::newRow("CategoryAxis_2_1") << imports_2_1() + "CategoryAxis{}";
                 QTest::newRow("ScatterSeries_2_1") << imports_2_1() + "ScatterSeries{}";
                 QTest::newRow("LineSeries_2_1") << imports_2_1() + "LineSeries{}";
                 QTest::newRow("SplineSeries_2_1") << imports_2_1() + "SplineSeries{}";
             }
             void tst_qml::checkPlugin()
             {
                 QFETCH(QString, source);
                 QQmlEngine engine;
                 engine.addImportPath(QString::fromLatin1("%1/%2").arg(QCoreApplication::applicationDirPath(), QLatin1String("qml")));
                 QQmlComponent component(&engine);
                 component.setData(source.toLatin1(), QUrl());
                 QVERIFY2(!component.isError(), qPrintable(componentErrors(&component)));
                 TRY_COMPARE(component.status(), QQmlComponent::Ready);
                 QObject *obj = component.create();
                 QVERIFY(obj != 0);
                 delete obj;
             }
             QTEST_MAIN(tst_qml)
             #include "tst_qml.moc"

tests/manual/chartviewer/charts/charts.pri +1 -1

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/font/font.cpp \
                 $$PWD/xyseries/linechart.cpp \
                 $$PWD/xyseries/scatterchart.cpp \
                 $$PWD/xyseries/splinechart.cpp \
                 $$PWD/xyseries/areachart.cpp \
                 $$PWD/barseries/verticalstackedbarchart.cpp \
                 $$PWD/barseries/horizontalstackedbarchart.cpp \
                 $$PWD/barseries/verticalbarchart.cpp \
                 $$PWD/barseries/horizontalbarchart.cpp \
                 $$PWD/barseries/horizontalpercentbarchart.cpp \
                 $$PWD/barseries/verticalpercentbarchart.cpp \
                 $$PWD/pieseries/piechart.cpp \
                 $$PWD/pieseries/donutchart.cpp \
                 $$PWD/axis/valueaxis.cpp \
                 $$PWD/axis/logvalueaxisx.cpp \
                 $$PWD/axis/logvalueaxisy.cpp \
                 $$PWD/axis/categoryaxis.cpp \
                 $$PWD/axis/barcategoryaxisx.cpp \
                 $$PWD/axis/barcategoryaxisy.cpp \
                 $$PWD/axis/barcategoryaxisxlogy.cpp \
                 $$PWD/axis/barcategoryaxisylogx.cpp \
                 $$PWD/multiaxis/multivalueaxis.cpp \
                 $$PWD/multiaxis/multivalueaxis2.cpp \
                 $$PWD/multiaxis/multivalueaxis3.cpp \
                 $$PWD/multiaxis/multivalueaxis4.cpp \
                 $$PWD/multiaxis/multivaluebaraxis.cpp \
                 $$PWD/size/sizecharts.cpp \
                 $$PWD/domain/barlogy.cpp \
                 $$PWD/domain/barlogx.cpp \
                 $$PWD/domain/barstackedlogy.cpp \
                 $$PWD/domain/barstackedlogx.cpp \
                 $$PWD/domain/barpercentlogy.cpp \
                 $$PWD/domain/barpercentlogx.cpp \
                 $$PWD/domain/linelogxlogy.cpp \
                 $$PWD/domain/linelogxy.cpp \
                 $$PWD/domain/linexlogy.cpp \
                 $$PWD/domain/splinelogxlogy.cpp \
                 $$PWD/domain/splinelogxy.cpp \
                 $$PWD/domain/splinexlogy.cpp \
                 $$PWD/domain/scatterlogxlogy.cpp \
                 $$PWD/domain/scatterlogxy.cpp \
                 $$PWD/domain/scatterxlogy.cpp
-            !linux-arm*: {
+            !contains(QT_COORD_TYPE, float): {
             SOURCES += \
                 $$PWD/axis/datetimeaxisx.cpp \
                 $$PWD/axis/datetimeaxisy.cpp
             }

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