HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2850:57e4c71e5532

Clear chart image to transparent when necessary....

Miikka Heikkinen -

r2850:57e4c71e5532

parent child

Context file:

r2850:57e4c71e5532

Collapse all files

src/charts/qabstractseries.cpp +4 -4

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** 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 http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #include <QtCharts/QAbstractSeries>
             #include <private/qabstractseries_p.h>
             #include <private/chartdataset_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \inmodule Qt Charts
                 \brief Base class for all Qt Chart series.
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmltype AbstractSeries
                 \instantiates QAbstractSeries
                 \inqmlmodule QtCharts
                 \brief Base class for all Qt Chart series.
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
                 \value SeriesTypeBoxPlot
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \property QAbstractSeries::useOpenGL
                 \brief Specifies whether or not the series drawing is accelerated with OpenGL.
                 Drawing series with OpenGL is supported only for QLineSeries and QScatterSeries.
                 Line series used as edge series for a QAreaSeries cannot use OpenGL acceleration.
                 When a chart contains any series that are drawn with OpenGL, a transparent QOpenGLWidget
                 is created on top of the chart plot area. The accelerated series are not drawn on the underlying
                 QGraphicsView, but are instead drawn on the created QOpenGLWidget.
                 Performance gained from using OpenGL to accelerate series drawing depends on the underlying
                 hardware, but in most cases it is significant. For example, on a standard desktop computer,
                 enabling OpenGL acceleration for a series typically allows rendering at least hundred times
                 more points without reduction on the frame rate.
                 Chart size also has less effect on the frame rate.
                 The OpenGL acceleration of series drawing is meant for use cases that need fast drawing of
                 large numbers of points. It is optimized for efficiency, and therefore the series using
                 it lack support for many features available to non-accelerated series:
                 \list
                 \li Series animations are not supported for accelerated series.
                 \li Antialiasing is not supported for accelerated series.
                 \li Point labels are not supported for accelerated series.
                 \li Pen styles and marker shapes are ignored for accelerated series.
                     Only solid lines and plain scatter dots are supported.
                     The scatter dots may be circular or rectangular, depending on the underlying graphics
                     hardware and drivers.
                 \li Polar charts do not support accelerated series.
                 \li Mouse events are not supported for accelerated series.
-                \li Enabling chart drop shadow is not recommended when using accelerated series,
+                \li Enabling chart drop shadow or using transparent chart background color is not recommended
-                    as that can slow the frame rate down significantly.
+                    when using accelerated series, as that can slow the frame rate down significantly.
                 \endlist
                 These additional restrictions stem from the fact that the accelerated series is drawn on a
                 separate widget on top of the chart:
                 \list
                 \li If you draw any graphics items on top of a chart containing an accelerated series,
                     the accelerated series is drawn over those items.
                 \li To enable QOpenGLWidget to be partially transparent, it needs to be stacked on top of
                     all other widgets. This means you cannot have other widgets partially covering the
                     chart when using accelerated series.
                 \li Accelerated series are not supported for use cases where the graphics scene has more than
                     one graphics view attached to it.
                 \li Accelerated series are not supported for use cases where the chart doesn't fill the entire
                     graphics view or has non-default geometry. For example, scrolling the view with scroll
                     bars or adding transformations to the graphics view cause the accelerated series to
                     be drawn in incorrect position related to the chart.
                 \endlist
                 The default value is \c{false}.
             */
             /*!
                 \qmlproperty bool AbstractSeries::useOpenGL
                 Specifies whether or not the series is drawn with OpenGL.
                 Drawing series with OpenGL is supported only for LineSeries and ScatterSeries.
                 Line series used as edge series for a AreaSeries cannot use OpenGL acceleration.
                 When a chart contains any series that are drawn with OpenGL, an additional transparent child
                 node is created for the ChartView node. The accelerated series are not drawn on the
                 ChartView node, but are instead drawn on the child node.
                 Performance gained from using OpenGL to accelerate series drawing depends on the underlying
                 hardware, but in most cases it is significant. For example, on a standard desktop computer,
                 enabling OpenGL acceleration for a series typically allows rendering at least hundred times
                 more points without reduction on the frame rate.
                 Chart size also has less effect on the frame rate.
                 The biggest performance sink when rendering ChartView is rendering and uploading the underlying
                 chart texture. If the underlying chart itself is not changing rapidly, significant extra
                 performance is gained from not needing to regenerate the chart texture for each frame.
                 The OpenGL acceleration of series drawing is meant for use cases that need fast drawing of
                 large numbers of points. It is optimized for efficiency, and therefore the series using
                 it lack support for many features available to non-accelerated series:
                 \list
                 \li Series animations are not supported for accelerated series.
                 \li Antialiasing is not supported for accelerated series.
                 \li Point labels are not supported for accelerated series.
                 \li Marker shapes are ignored for accelerated series.
                     Only plain scatter dots are supported.
                     The scatter dots may be circular or rectangular, depending on the underlying graphics
                     hardware and drivers.
                 \li Polar charts do not support accelerated series.
                 \li Mouse events are not supported for accelerated series.
-                \li Enabling chart drop shadow is not recommended when using accelerated series,
+                \li Enabling chart drop shadow or using transparent chart background color is not recommended
-                    as that can slow the frame rate down significantly.
+                    when using accelerated series, as that can slow the frame rate down significantly.
                 \endlist
                 The default value is \c{false}.
             */
             /*!
                 \fn void QAbstractSeries::useOpenGLChanged()
                 Emitted when the useOpenGL property value changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onUseOpenGLChanged()
                 Emitted when the useOpenGL property value changes.
             */
             /*!
                 \internal
                 \brief Constructs QAbstractSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Series still bound to a chart when destroyed!");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             void QAbstractSeries::setUseOpenGL(bool enable)
             {
             #ifdef QT_NO_OPENGL
                 Q_UNUSED(enable)
             #else
                 bool polarChart = d_ptr->m_chart && d_ptr->m_chart->chartType() == QChart::ChartTypePolar;
                 bool supportedSeries = (type() == SeriesTypeLine || type() == SeriesTypeScatter);
                 if ((!enable || !d_ptr->m_blockOpenGL)
                         && supportedSeries
                         && enable != d_ptr->m_useOpenGL
                         && (!enable || !polarChart)) {
                     d_ptr->m_useOpenGL = enable;
                     emit useOpenGLChanged();
                 }
             #endif
             }
             bool QAbstractSeries::useOpenGL() const
             {
                 return d_ptr->m_useOpenGL;
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 \brief Sets the visibility of the series to true.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \note If multiple axes of same orientation are attached to same series,
                    they will have same min/max ranges.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0),
                   m_useOpenGL(false),
                   m_blockOpenGL(false)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::setPresenter(ChartPresenter *presenter)
             {
                 m_presenter = presenter;
             }
             ChartPresenter *QAbstractSeriesPrivate::presenter() const
             {
                 return m_presenter;
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                               QEasingCurve &curve)
             {
                 Q_UNUSED(options);
                 Q_UNUSED(duration);
                 Q_UNUSED(curve);
             }
             bool QAbstractSeriesPrivate::reverseXAxis()
             {
                 bool reverseXAxis = false;
                 if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
                     int i = 0;
                     while (i < m_axes.size()) {
                         if (m_axes.at(i)->orientation() == Qt::Horizontal && m_axes.at(i)->isReverse()) {
                             reverseXAxis = true;
                             break;
                         }
                         i++;
                     }
                 }
                 return reverseXAxis;
             }
             bool QAbstractSeriesPrivate::reverseYAxis()
             {
                 bool reverseYAxis = false;
                 if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
                     int i = 0;
                     while (i < m_axes.size()) {
                         if (m_axes.at(i)->orientation() == Qt::Vertical && m_axes.at(i)->isReverse()) {
                             reverseYAxis = true;
                             break;
                         }
                         i++;
                     }
                 }
                 return reverseYAxis;
             }
             // This function can be used to explicitly block OpenGL use from some otherwise supported series,
             // such as the line series used as edge series of an area series.
             void QAbstractSeriesPrivate::setBlockOpenGL(bool enable)
             {
                 m_blockOpenGL = enable;
                 if (enable)
                     q_ptr->setUseOpenGL(false);
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechart.cpp +12 -1

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** 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 http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #include "declarativechart.h"
             #include <QtGui/QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
             #include "declarativechartnode.h"
             #include "declarativerendernode.h"
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include "declarativemargins.h"
             #include <private/chartdataset_p.h>
             #include "declarativeaxes.h"
             #include <private/qchart_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QPolarChart>
             #ifndef QT_ON_ARM
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtWidgets/QGraphicsSceneHoverEvent>
             #include <QtWidgets/QApplication>
             #include <QtCore/QTimer>
             #include <QtCore/QThread>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCharts
                 \brief Chart element.
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animationOptions
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
              \qmlproperty int ChartView::animationDuration
              The duration of the animation for the chart.
              */
             /*!
              \qmlproperty easing ChartView::animationEasingCurve
              The easing curve of the animation for the chart.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart.
               See the Qt documentation for more details of Font.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty color ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty real ChartView::backgroundRoundness
               The diameter of the rounding circle at the corners of the chart background.
             */
             /*!
               \qmlproperty color ChartView::plotAreaColor
               The color of the background of the chart's plot area. By default plot area background uses chart's
               background color.
               \sa ChartView::backgroundColor
             */
             /*!
               \qmlproperty list<AbstractAxis> ChartView::axes
               The axes of the ChartView.
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::margins
             */
             /*!
               \qmlproperty Margins ChartView::margins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend.
             */
             /*!
               \qmlproperty bool ChartView::localizeNumbers
               \since QtCharts 2.0
               When \c{true}, all generated numbers appearing in various series and axis labels will be
               localized using the default QLocale of the application, which defaults to the system locale.
               When \c{false}, the "C" locale is always used.
               Defaults to \c{false}.
               \sa locale
             */
             /*!
               \qmlproperty locale ChartView::locale
               \since QtCharts 2.0
               Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
               This also determines the locale used to format DateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisX(AbstractAxis axis, AbstractSeries series)
               Set the x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisY(AbstractAxis axis, AbstractSeries series)
               Set the y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoom(real factor)
               Zooms in by \a factor on the center of the chart.
               A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
             */
             /*!
               \qmlmethod ChartView::zoomIn()
               Zooms in the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomIn(rect rectangle)
               Zooms in the view to a maximum level at which \a rectangle is still fully visible.
               \note This is not supported for polar charts.
             */
             /*!
               \qmlmethod ChartView::zoomOut()
               Zooms out the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomReset()
               Resets the series domains to what they were before any zoom method was called.
               Note that this will also reset any scrolls and explicit axis range settings done between
               the first zoom operation and calling this method. If no zoom operation has been
               done, this method does nothing.
             */
             /*!
               \qmlmethod ChartView::isZoomed()
               Returns true if any series has a zoomed domain.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod point ChartView::mapToValue(point position, AbstractSeries series)
               Returns the value in the \a series domain that corresponds to the \a position relative to the
               chart.
             */
             /*!
               \qmlmethod point ChartView::mapToPosition(point value, AbstractSeries series)
               Returns the position on the chart that corresponds to the \a value in the \a series domain.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QQuickItem *parent)
                 : QQuickItem(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
                 : QQuickItem(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
                 m_sceneImage = 0;
                 m_sceneImageDirty = false;
+                m_sceneImageNeedsClear = false;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
                 setFlag(ItemHasContents, true);
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
                 m_chart->d_ptr->m_presenter->glSetUseWidget(false);
                 m_glXYDataManager = m_chart->d_ptr->m_dataset->glXYSeriesDataManager();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
                 connect(m_scene, &QGraphicsScene::changed, this, &DeclarativeChart::sceneChanged);
                 connect(this, &DeclarativeChart::needRender, this, &DeclarativeChart::renderScene,
                         Qt::QueuedConnection);
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 connect(m_chart, &QChart::plotAreaChanged, this, &DeclarativeChart::plotAreaChanged);
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit marginsChanged();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
                 delete m_sceneImage;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Connect to axis changed signals (unless this is a pie series)
                         if (!qobject_cast<DeclarativePieSeries *>(series)) {
                             connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QQuickItem::componentComplete();
             }
             void DeclarativeChart::seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                                           Qt::Orientations orientation,
                                                           Qt::Alignment alignment)
             {
                 if (!series->attachedAxes().contains(axis)) {
                     // Remove & delete old axes that are not attached to any other series
                     foreach (QAbstractAxis* oldAxis, m_chart->axes(orientation, series)) {
                         bool otherAttachments = false;
                         if (oldAxis != axis) {
                             foreach (QAbstractSeries *oldSeries, m_chart->series()) {
                                 if (oldSeries != series && oldSeries->attachedAxes().contains(oldAxis)) {
                                     otherAttachments = true;
                                     break;
                                 }
                             }
                             if (!otherAttachments) {
                                 m_chart->removeAxis(oldAxis);
                                 delete oldAxis;
                             }
                         }
                     }
                     if (!m_chart->axes(orientation).contains(axis))
                         m_chart->addAxis(axis, alignment);
                     series->attachAxis(axis);
                 }
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignBottom);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignTop);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignLeft);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignRight);
                 } else {
                     qWarning() << "Trying to set axisYRight to null.";
                 }
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QQuickItem::geometryChanged(newGeometry, oldGeometry);
             }
             QSGNode *DeclarativeChart::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
             {
                 DeclarativeChartNode *node = static_cast<DeclarativeChartNode *>(oldNode);
                 if (!node) {
                     node =  new DeclarativeChartNode(window());
                     connect(window(), &QQuickWindow::beforeRendering,
                             node->glRenderNode(), &DeclarativeRenderNode::render);
                 }
                 const QRectF &bRect = boundingRect();
                 // Update GL data
                 if (m_glXYDataManager->dataMap().size() || m_glXYDataManager->mapDirty()) {
                     const QRectF &plotArea = m_chart->plotArea();
                     const QSizeF &chartAreaSize = m_chart->size();
                     // We can't use chart's plot area directly, as graphicscene has some internal minimum size
                     const qreal normalizedX = plotArea.x() / chartAreaSize.width();
                     const qreal normalizedY = plotArea.y() / chartAreaSize.height();
                     const qreal normalizedWidth = plotArea.width() / chartAreaSize.width();
                     const qreal normalizedHeight = plotArea.height() / chartAreaSize.height();
                     QRectF adjustedPlotArea(normalizedX * bRect.width(),
                                             normalizedY * bRect.height(),
                                             normalizedWidth * bRect.width(),
                                             normalizedHeight * bRect.height());
                     const QSize &adjustedPlotSize = adjustedPlotArea.size().toSize();
                     if (adjustedPlotSize != node->glRenderNode()->textureSize())
                         node->glRenderNode()->setTextureSize(adjustedPlotSize);
                     node->glRenderNode()->setRect(adjustedPlotArea);
                     node->glRenderNode()->setSeriesData(m_glXYDataManager->mapDirty(),
                                                         m_glXYDataManager->dataMap());
                     // Clear dirty flags from original xy data
                     m_glXYDataManager->clearAllDirty();
                 }
                 // Copy chart (if dirty) to chart node
                 if (m_sceneImageDirty) {
                     node->createTextureFromImage(*m_sceneImage);
                     m_sceneImageDirty = false;
                 }
                 node->setRect(bRect);
                 return node;
             }
             void DeclarativeChart::sceneChanged(QList<QRectF> region)
             {
                 const int count = region.size();
                 const qreal limitSize = 0.01;
                 if (count && !m_updatePending) {
                     qreal totalSize = 0.0;
                     for (int i = 0; i < count; i++) {
                         const QRectF &reg = region.at(i);
                         totalSize += (reg.height() * reg.width());
                         if (totalSize >= limitSize)
                             break;
                     }
                     // Ignore region updates that change less than small fraction of a pixel, as there is
                     // little point regenerating the image in these cases. These are typically cases
                     // where OpenGL series are drawn to otherwise static chart.
                     if (totalSize >= limitSize) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
                         emit needRender();
                     } else {
                         // We do want to call update to trigger possible gl series updates.
                         update();
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
                 m_sceneImageDirty = true;
                 QSize chartSize = m_chart->size().toSize();
                 if (!m_sceneImage || chartSize != m_sceneImage->size()) {
                     delete m_sceneImage;
                     m_sceneImage = new QImage(chartSize, QImage::Format_ARGB32);
-                    m_sceneImage->fill(Qt::transparent);
+                    m_sceneImageNeedsClear = true;
                 }
+                if (m_sceneImageNeedsClear) {
+                    m_sceneImage->fill(Qt::transparent);
+                    // Don't clear the flag if chart background has any transparent element to it
+                    if (m_chart->backgroundBrush().color().alpha() == 0xff && !m_chart->isDropShadowEnabled())
+                        m_sceneImageNeedsClear = false;
+                }
                 QPainter painter(m_sceneImage);
                 if (antialiasing()) {
                     painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing
                                            | QPainter::SmoothPixmapTransform);
                 }
                 QRect renderRect(QPoint(0, 0), chartSize);
                 m_scene->render(&painter, renderRect, renderRect);
                 update();
             }
             void DeclarativeChart::mousePressEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 mouseEvent.setScreenPos(event->globalPos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(event->buttons());
                 mouseEvent.setButton(event->button());
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
                 m_mousePressButtons = event->buttons();
                 m_mousePressButton = Qt::NoButton;
             }
             void DeclarativeChart::hoverMoveEvent(QHoverEvent *event)
             {
                 // Convert hover move to mouse move, since we don't seem to get actual mouse move events.
                 // QGraphicsScene generates hover events from mouse move events, so we don't need
                 // to pass hover events there.
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 // Hover events do not have global pos in them, and the screen position doesn't seem to
                 // matter anyway in this use case, so just pass event pos instead of trying to
                 // calculate the real screen position.
                 mouseEvent.setScreenPos(event->pos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 m_lastMouseMoveScenePoint = mouseEvent.scenePos();
                 m_lastMouseMoveScreenPoint = mouseEvent.screenPos();
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseDoubleClickEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setAnimationDuration(int msecs)
             {
                 if (msecs != m_chart->animationDuration()) {
                     m_chart->setAnimationDuration(msecs);
                     emit animationDurationChanged(msecs);
                 }
             }
             int DeclarativeChart::animationDuration() const
             {
                 return m_chart->animationDuration();
             }
             void DeclarativeChart::setAnimationEasingCurve(const QEasingCurve &curve)
             {
                 if (curve != m_chart->animationEasingCurve()) {
                     m_chart->setAnimationEasingCurve(curve);
                     emit animationEasingCurveChanged(curve);
                 }
             }
             QEasingCurve DeclarativeChart::animationEasingCurve() const
             {
                 return m_chart->animationEasingCurve();
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
+                    if (color.alpha() < 0xff)
+                        m_sceneImageNeedsClear = true;
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCharts::DeclarativeChart::setPlotAreaColor(QColor color)
             {
                 QBrush b = m_chart->plotAreaBackgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setPlotAreaBackgroundBrush(b);
                     m_chart->setPlotAreaBackgroundVisible(true);
                     emit plotAreaColorChanged();
                 }
             }
             QColor QtCharts::DeclarativeChart::plotAreaColor()
             {
                 return m_chart->plotAreaBackgroundBrush().color();
             }
             void DeclarativeChart::setLocalizeNumbers(bool localize)
             {
                 if (m_chart->localizeNumbers() != localize) {
                     m_chart->setLocalizeNumbers(localize);
                     emit localizeNumbersChanged();
                 }
             }
             bool DeclarativeChart::localizeNumbers() const
             {
                 return m_chart->localizeNumbers();
             }
             void QtCharts::DeclarativeChart::setLocale(const QLocale &locale)
             {
                 if (m_chart->locale() != locale) {
                     m_chart->setLocale(locale);
                     emit localeChanged();
                 }
             }
             QLocale QtCharts::DeclarativeChart::locale() const
             {
                 return m_chart->locale();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
+                    m_sceneImageNeedsClear = true;
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::backgroundRoundness() const
             {
                 return m_chart->backgroundRoundness();
             }
             void DeclarativeChart::setBackgroundRoundness(qreal diameter)
             {
                 if (m_chart->backgroundRoundness() != diameter) {
+                    m_sceneImageNeedsClear = true;
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void DeclarativeChart::zoomIn(const QRectF &rectangle)
             {
                 m_chart->zoomIn(rectangle);
             }
             void DeclarativeChart::zoomOut()
             {
                 m_chart->zoomOut();
             }
             void DeclarativeChart::zoomReset()
             {
                 m_chart->zoomReset();
             }
             bool DeclarativeChart::isZoomed()
             {
                 return m_chart->isZoomed();
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QQmlListProperty<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QQmlListProperty<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             }
             void DeclarativeChart::axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count();
                 }
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]);
                     return axes.at(index);
                 }
                 return 0;
             }
             void DeclarativeChart::axesClearFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 // Empty implementation
                 Q_UNUSED(list);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach (QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea: {
                     DeclarativeAreaSeries *area = new DeclarativeAreaSeries();
                     DeclarativeLineSeries *line = new DeclarativeLineSeries();
                     line->setParent(area);
                     area->setUpperSeries(line);
                     series = area;
                     break;
                 }
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBoxPlot:
                     series = new DeclarativeBoxPlotSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 if (series) {
                     // Connect to axis changed signals (unless this is a pie series)
                     if (!qobject_cast<DeclarativePieSeries *>(series)) {
                         connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                     }
                     series->setName(name);
                     m_chart->addSeries(series);
                     if (!axisX || !axisY)
                         initializeAxes(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Horizontal, Qt::AlignBottom);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Vertical, Qt::AlignLeft);
             }
             QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series)
             {
                 if (!series) {
                     qWarning() << "No axis type defined for null series";
                     return 0;
                 }
                 foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) {
                     if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation))
                         return existingAxis;
                 }
                 switch (series->d_ptr->defaultAxisType(orientation)) {
                 case QAbstractAxis::AxisTypeValue:
                     return new QValueAxis(this);
                 case QAbstractAxis::AxisTypeBarCategory:
                     return new QBarCategoryAxis(this);
                 case QAbstractAxis::AxisTypeCategory:
                     return new QCategoryAxis(this);
             #ifndef QT_ON_ARM
                 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

src/chartsqml2/declarativechart.h +1 0

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** 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 http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <private/glxyseriesdata_p.h>
             #include <QtCore/QtGlobal>
             #include <QtQuick/QQuickItem>
             #include <QtWidgets/QGraphicsScene>
             #include <QtCharts/QChart>
             #include <QtCore/QLocale>
             QT_CHARTS_BEGIN_NAMESPACE
             class DeclarativeMargins;
             class Domain;
             class DeclarativeAxes;
             class DeclarativeChart : public QQuickItem
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(int animationDuration READ animationDuration WRITE setAnimationDuration NOTIFY animationDurationChanged REVISION 5)
                 Q_PROPERTY(QEasingCurve animationEasingCurve READ animationEasingCurve WRITE setAnimationEasingCurve NOTIFY animationEasingCurveChanged REVISION 5)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QLegend *legend READ legend CONSTANT)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)
                 Q_PROPERTY(bool dropShadowEnabled READ dropShadowEnabled WRITE setDropShadowEnabled NOTIFY dropShadowEnabledChanged)
                 Q_PROPERTY(qreal backgroundRoundness READ backgroundRoundness WRITE setBackgroundRoundness NOTIFY backgroundRoundnessChanged REVISION 3)
                 Q_PROPERTY(DeclarativeMargins *margins READ margins NOTIFY marginsChanged REVISION 2)
                 Q_PROPERTY(QRectF plotArea READ plotArea NOTIFY plotAreaChanged REVISION 1)
                 Q_PROPERTY(QColor plotAreaColor READ plotAreaColor WRITE setPlotAreaColor NOTIFY plotAreaColorChanged REVISION 3)
                 Q_PROPERTY(QQmlListProperty<QAbstractAxis> axes READ axes REVISION 2)
                 Q_PROPERTY(bool localizeNumbers READ localizeNumbers WRITE setLocalizeNumbers NOTIFY localizeNumbersChanged REVISION 4)
                 Q_PROPERTY(QLocale locale READ locale WRITE setLocale NOTIFY localeChanged REVISION 4)
                 Q_ENUMS(Animation)
                 Q_ENUMS(Theme)
                 Q_ENUMS(SeriesType)
             public:
                 // duplicating enums from QChart to make the QML api namings 1-to-1 with the C++ api
                 enum Theme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy,
                     ChartThemeQt
                 };
                 enum Animation {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypeBoxPlot,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             public:
                 DeclarativeChart(QQuickItem *parent = 0);
                 ~DeclarativeChart();
             public: // From parent classes
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
                 QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void hoverMoveEvent(QHoverEvent *event);
                 void mouseDoubleClickEvent(QMouseEvent *event);
             private Q_SLOTS:
                 void handleAntialiasingChanged(bool enable);
                 void sceneChanged(QList<QRectF> region);
                 void renderScene();
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setAnimationDuration(int msecs);
                 int animationDuration() const;
                 void setAnimationEasingCurve(const QEasingCurve &curve);
                 QEasingCurve animationEasingCurve() const;
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 QFont titleFont() const;
                 void setTitleFont(const QFont &font);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
                 void setPlotAreaColor(QColor color);
                 QColor plotAreaColor();
                 void setLocalizeNumbers(bool localize);
                 bool localizeNumbers() const;
                 void setLocale(const QLocale &locale);
                 QLocale locale() const;
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 qreal backgroundRoundness() const;
                 void setBackgroundRoundness(qreal diameter);
                 // Margins & plotArea
                 DeclarativeMargins *margins() { return m_margins; }
                 QRectF plotArea() { return m_chart->plotArea(); }
                 // Axis handling
                 QAbstractAxis *defaultAxis(Qt::Orientation orientation, QAbstractSeries *series);
                 void initializeAxes(QAbstractSeries *series);
                 void doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes);
                 QQmlListProperty<QAbstractAxis> axes();
                 static void axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element);
                 static int axesCountFunc(QQmlListProperty<QAbstractAxis> *list);
                 static QAbstractAxis *axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index);
                 static void axesClearFunc(QQmlListProperty<QAbstractAxis> *list);
             public:
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(int type, QString name = "", QAbstractAxis *axisX = 0, QAbstractAxis *axisY = 0);
                 Q_INVOKABLE void removeSeries(QAbstractSeries *series);
                 Q_INVOKABLE void removeAllSeries() { m_chart->removeAllSeries(); }
                 Q_INVOKABLE void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisX(QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisY(QAbstractSeries *series = 0);
                 Q_INVOKABLE void zoom(qreal factor);
                 Q_REVISION(5) Q_INVOKABLE void zoomIn();
                 Q_REVISION(5) Q_INVOKABLE void zoomIn(const QRectF &rectangle);
                 Q_REVISION(5) Q_INVOKABLE void zoomOut();
                 Q_REVISION(5) Q_INVOKABLE void zoomReset();
                 Q_REVISION(5) Q_INVOKABLE bool isZoomed();
                 Q_INVOKABLE void scrollLeft(qreal pixels);
                 Q_INVOKABLE void scrollRight(qreal pixels);
                 Q_INVOKABLE void scrollUp(qreal pixels);
                 Q_INVOKABLE void scrollDown(qreal pixels);
                 Q_REVISION(5) Q_INVOKABLE QPointF mapToValue(const QPointF &position,
                                                              QAbstractSeries *series = 0);
                 Q_REVISION(5) Q_INVOKABLE QPointF mapToPosition(const QPointF &value,
                                                                 QAbstractSeries *series = 0);
             Q_SIGNALS:
                 void axisLabelsChanged();
                 void titleColorChanged(QColor color);
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
                 Q_REVISION(2) void marginsChanged();
                 void plotAreaChanged(QRectF plotArea);
                 void seriesAdded(QAbstractSeries *series);
                 void seriesRemoved(QAbstractSeries *series);
                 Q_REVISION(3) void plotAreaColorChanged();
                 Q_REVISION(3) void backgroundRoundnessChanged(qreal diameter);
                 Q_REVISION(4) void localizeNumbersChanged();
                 Q_REVISION(4) void localeChanged();
                 Q_REVISION(5) void animationDurationChanged(int msecs);
                 Q_REVISION(5) void animationEasingCurveChanged(QEasingCurve curve);
                 void needRender();
             private Q_SLOTS:
                 void changeMargins(int top, int bottom, int left, int right);
                 void handleAxisXSet(QAbstractAxis *axis);
                 void handleAxisYSet(QAbstractAxis *axis);
                 void handleAxisXTopSet(QAbstractAxis *axis);
                 void handleAxisYRightSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series);
             protected:
                 explicit DeclarativeChart(QChart::ChartType type, QQuickItem *parent);
             private:
                 void initChart(QChart::ChartType type);
                 void seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                             Qt::Orientations orientation, Qt::Alignment alignment);
                 void findMinMaxForSeries(QAbstractSeries *series,Qt::Orientations orientation,
                                          qreal &min, qreal &max);
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
                 QGraphicsScene *m_scene;
                 QPointF m_mousePressScenePoint;
                 QPoint m_mousePressScreenPoint;
                 QPointF m_lastMouseMoveScenePoint;
                 QPoint m_lastMouseMoveScreenPoint;
                 Qt::MouseButton m_mousePressButton;
                 Qt::MouseButtons m_mousePressButtons;
                 QImage *m_sceneImage;
                 bool m_sceneImageDirty;
                 bool m_updatePending;
                 Qt::HANDLE m_paintThreadId;
                 Qt::HANDLE m_guiThreadId;
                 DeclarativeMargins *m_margins;
                 GLXYSeriesDataManager *m_glXYDataManager;
+                bool m_sceneImageNeedsClear;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // DECLARATIVECHART_H

General Comments 0

Write
Preview

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

No TODOs yet

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

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