HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2866:bbf52870f4e3

Merge remote-tracking branch 'origin/5.6' into 5.7...

Liang Qi -

r2866:bbf52870f4e3

parent child

Context file:

r2866:bbf52870f4e3

Collapse all files

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

src/charts/chartpresenter_p.h +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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QChart> //because of QChart::ChartThemeId
             #include <private/glwidget_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QMargins>
             #include <QtCore/QLocale>
             #include <QtCore/QPointer>
             #include <QtCore/QEasingCurve>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setLocalizeNumbers(bool localize);
                 inline bool localizeNumbers() const { return m_localizeNumbers; }
                 void setLocale(const QLocale &locale);
                 inline const QLocale &locale() const { return m_locale; }
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void setAnimationDuration(int msecs);
                 int animationDuration() const { return m_animationDuration; }
                 void setAnimationEasingCurve(const QEasingCurve &curve);
                 QEasingCurve animationEasingCurve() const { return m_animationCurve; }
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle,
                                              qreal maxWidth, qreal maxHeight, QRectF &boundingRect);
                 inline static qreal textMargin() { return qreal(0.5); }
                 QString numberToString(double value, char f = 'g', int prec = 6);
                 QString numberToString(int value);
-                void ensureGLWidget();
+                void updateGLWidget();
                 void glSetUseWidget(bool enable) { m_glUseWidget = enable; }
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             Q_SIGNALS:
                 void plotAreaChanged(const QRectF &plotArea);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 int m_animationDuration;
                 QEasingCurve m_animationCurve;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
                 bool m_localizeNumbers;
                 QLocale m_locale;
             #ifndef QT_NO_OPENGL
                 QPointer<GLWidget> m_glWidget;
             #endif
                 bool m_glUseWidget;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/charts/xychart/xychart.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 <private/xychart_p.h>
             #include <QtCharts/QXYSeries>
             #include <private/qxyseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/glxyseriesdata_p.h>
             #include <QtCharts/QXYModelMapper>
             #include <private/qabstractaxis_p.h>
             #include <QtGui/QPainter>
             #include <QtCore/QAbstractItemModel>
             QT_CHARTS_BEGIN_NAMESPACE
             XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
                   ChartItem(series->d_func(),item),
                   m_series(series),
                   m_animation(0),
                   m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(series, SIGNAL(pointsRemoved(int, int)), this, SLOT(handlePointsRemoved(int, int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
                 QObject::connect(this, SIGNAL(pressed(QPointF)), series, SIGNAL(pressed(QPointF)));
                 QObject::connect(this, SIGNAL(released(QPointF)), series, SIGNAL(released(QPointF)));
                 QObject::connect(this, SIGNAL(doubleClicked(QPointF)), series, SIGNAL(doubleClicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF> &points)
             {
                 m_points = points;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             // Returns a vector with same size as geometryPoints vector, indicating
             // the off grid status of points.
             QVector<bool> XYChart::offGridStatusVector()
             {
                 qreal minX = domain()->minX();
                 qreal maxX = domain()->maxX();
                 qreal minY = domain()->minY();
                 qreal maxY = domain()->maxY();
                 QVector<bool> returnVector;
                 returnVector.resize(m_points.size());
                 // During remove animation series may have different number of points,
                 // so ensure we don't go over the index. No need to check for zero points, this
                 // will not be called in such a situation.
                 const int seriesLastIndex = m_series->count() - 1;
                 for (int i = 0; i < m_points.size(); i++) {
                     const QPointF &seriesPoint = m_series->at(qMin(seriesLastIndex, i));
                     if (seriesPoint.x() < minX
                         || seriesPoint.x() > maxX
                         || seriesPoint.y() < minY
                         || seriesPoint.y() > maxY) {
                         returnVector[i] = true;
                     } else {
                         returnVector[i] = false;
                     }
                 }
                 return returnVector;
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 } else {
                     m_points = newPoints;
                     updateGeometry();
                 }
             }
             void XYChart::updateGlChart()
             {
-                presenter()->ensureGLWidget();
                 dataSet()->glXYSeriesDataManager()->setPoints(m_series, domain());
+                presenter()->updateGLWidget();
                 updateGeometry();
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
                         points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
                         QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
                                                                          m_validData);
                         if (!m_validData)
                             m_points.clear();
                         else
                             points.insert(index, point);
                     }
                     updateChart(m_points, points, index);
                 }
             }
             void XYChart::handlePointRemoved(int index)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
                         points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
                         points.remove(index);
                     }
                     updateChart(m_points, points, index);
                 }
             }
             void XYChart::handlePointsRemoved(int index, int count)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
                         points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
                         points.remove(index, count);
                     }
                     updateChart(m_points, points, index);
                 }
             }
             void XYChart::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
                         points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
                                                                          m_validData);
                         if (!m_validData)
                             m_points.clear();
                         points = m_points;
                         if (m_validData)
                             points.replace(index, point);
                     }
                     updateChart(m_points, points, index);
                 }
             }
             void XYChart::handlePointsReplaced()
             {
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     // All the points were replaced -> recalculate
                     QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     updateChart(m_points, points, -1);
                 }
             }
             void XYChart::handleDomainUpdated()
             {
                 if (m_series->useOpenGL()) {
                     updateGlChart();
                 } else {
                     if (isEmpty()) return;
                     QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     updateChart(m_points, points);
                 }
             }
             bool XYChart::isEmpty()
             {
                 return domain()->isEmpty() || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechart.cpp +3 -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 "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_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);
+                    qreal dpr = window() ? window()->devicePixelRatio() : 1.0;
+                    m_sceneImage = new QImage(chartSize * dpr, QImage::Format_ARGB32);
+                    m_sceneImage->setDevicePixelRatio(dpr);
                     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_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

sync.profile +2 -2

             %modules = ( # path to module name map
                 "QtCharts" => "$basedir/src/charts",
             );
             %moduleheaders = ( # restrict the module headers to those found in relative path
             );
             %classnames = (
                 "qchartglobal.h" => "QChartGlobal"
             );
             # Module dependencies.
             # Every module that is required to build this module should have one entry.
             # Each of the module version specifiers can take one of the following values:
             #   - A specific Git revision.
             #   - any git symbolic ref resolvable from the module's repository (e.g. "refs/heads/master" to track master branch)
             #
             %dependencies = (
-                "qtbase" => "refs/heads/dev",
+                "qtbase" => "",
-                "qtdeclarative" => "refs/heads/dev",
+                "qtdeclarative" => "",
             );

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