qt/qtgraphs/src/graphs2d/qgraphsview.cpp

Revision control

++ // Copyright (C) 2023 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #include "graphs2d/qabstractseries.h"
++ #include "graphs2d/qabstractseries_p.h"
++ #if QT_CONFIG(graphs_2d_area)
++ #include <QtGraphs/qareaseries.h>
++ #include <private/arearenderer_p.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_bar)
++ #include <QtGraphs/qbarseries.h>
++ #include <private/barsrenderer_p.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ #include <QtGraphs/qpieseries.h>
++ #include <private/pierenderer_p.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
++ #include <QtGraphs/qlineseries.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_scatter)
++ #include <QtGraphs/qscatterseries.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_spline)
++ #include <QtGraphs/qsplineseries.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ #include <private/pointrenderer_p.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_custom)
++ #include <QtGraphs/qcustomseries.h>
++ #include <private/customrenderer_p.h>
++ #endif
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ #include "qcpainteritem_p.h"
++ #endif
++ #include <QTimer>
++ #include <QtQuick/private/qquickpinchhandler_p.h>
++ #include <QtQuick/private/qquickrectangle_p.h>
++ #include <QtCore/qset.h>
++ #include <private/axisrenderer_p.h>
++ #include <private/qabstractaxis_p.h>
++ #include <private/qgraphsview_p.h>
++
++ #include <qtgraphs_tracepoints_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_TRACE_PREFIX(qtgraphs,
++ "QT_BEGIN_NAMESPACE" \
++ "class QGraphsView;" \
++ "QT_END_NAMESPACE"
++ )
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsVieUpdatePolish_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsVieUpdatePolish_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewComponentComplete_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewComponentComplete_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewInsertSeries_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewInsertSeries_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateBarsRenderer_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateBarsRenderer_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateAxisRenderer_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateAxisRenderer_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreatePointRenderer_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreatePointRenderer_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreatePieRenderer_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreatePieRenderer_exit);
++
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateAreaRenderer_entry);
++ Q_TRACE_POINT(qtgraphs, QGraphs2DGraphsViewCreateAreaRenderer_exit);
++
++ /*!
++ \class QGraphsView
++ \inmodule QtGraphs
++ \internal
++ */
++
++ /*!
++ \qmltype GraphsView
++ \nativetype QGraphsView
++ \inqmlmodule QtGraphs
++ \ingroup graphs_qml_2D
++ \brief Base type for all Qt Graphs views.
++
++ This class collects the series and theming together and draws the graphs.
++ You will need to import Qt Graphs module to use this type:
++
++ \snippet doc_src_qmlgraphs.cpp 0
++
++ After that you can use GraphsView in your qml files:
++
++ \snippet doc_src_qmlgraphs.cpp 10
++
++ \image graphsview-minimal.png {Bar graph displaying values for 2023, 2024, and 2025}
++
++ \sa BarSeries, LineSeries, BarCategoryAxis, ValueAxis, GraphsTheme
++ */
++
++ Q_LOGGING_CATEGORY(lcGraphs2D, "qt.graphs2d.general")
++ Q_LOGGING_CATEGORY(lcViewProperties2D, "qt.graphs2d.graphsview.properties")
++ Q_LOGGING_CATEGORY(lcEvents2D, "qt.graphs2d.events")
++ Q_LOGGING_CATEGORY(lcCritical2D, "qt.graphs2d.critical")
++
++ QGraphsView::QGraphsView(QQuickItem *parent) :
++ QQuickItem(parent)
++ {
++ setFlag(QQuickItem::ItemHasContents);
++ setAcceptedMouseButtons(Qt::LeftButton);
++ setAcceptHoverEvents(true);
++ m_defaultTheme = new QGraphsTheme(this);
++ m_pinchHandler = new QQuickPinchHandler(this);
++ m_pinchHandler->setTarget(nullptr);
++
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ if (m_useCanvasPainter)
++ createCanvasPainter();
++ #endif
++
++ QObject::connect(m_pinchHandler,
++ &QQuickPinchHandler::scaleChanged,
++ this,
++ &QGraphsView::onPinchScaleChanged);
++ QObject::connect(m_pinchHandler,
++ &QQuickPinchHandler::grabChanged,
++ this,
++ &QGraphsView::onPinchGrabChanged);
++ m_initialized = true;
++ }
++
++ QGraphsView::~QGraphsView()
++ {
++ const auto slist = m_seriesList;
++ for (const auto &s : slist) {
++ if (auto series = qobject_cast<QAbstractSeries *>(s))
++ detachSeries(series);
++ }
++ if (m_axisX)
++ m_axisX->d_func()->setGraph(nullptr);
++ if (m_axisY)
++ m_axisY->d_func()->setGraph(nullptr);
++ }
++
++ void QGraphsView::onPinchScaleChanged(qreal delta)
++ {
++ if (m_axisRenderer)
++ m_axisRenderer->handlePinchScale(delta);
++ }
++
++ void QGraphsView::onPinchGrabChanged(QPointingDevice::GrabTransition transition, QEventPoint point)
++ {
++ if (m_axisRenderer)
++ m_axisRenderer->handlePinchGrab(transition, point);
++ }
++
++ /*!
++ \qmlmethod void GraphsView::addSeries(AbstractSeries series)
++ Appends a \a series into GraphsView.
++ If the \a series is null, it will not be added. If the \a series already
++ belongs to the graph, it will be moved into the end.
++ */
++ /*!
++ Appends a \a series into GraphsView.
++ If the \a series is null, it will not be added. If the \a series already
++ belongs to the graph, it will be moved into the end.
++ */
++ void QGraphsView::addSeries(QObject *series)
++ {
++ insertSeries(m_seriesList.size(), series);
++ }
++
++ /*!
++ \qmlmethod void GraphsView::insertSeries(int index, AbstractSeries series)
++ Inserts a \a series at the position specified by \a index.
++ If the \a series is null, it will not be inserted. If the \a series already
++ belongs to the graph, it will be moved into \a index.
++ */
++ /*!
++ Inserts a \a series at the position specified by \a index.
++ If the \a series is null, it will not be inserted. If the \a series already
++ belongs to the graph, it will be moved into \a index.
++ */
++ void QGraphsView::insertSeries(qsizetype index, QObject *object)
++ {
++ if (!isSeriesSupported(object))
++ return;
++
++ if (auto series = qobject_cast<QAbstractSeries *>(object)) {
++ Q_TRACE(QGraphs2DGraphsViewInsertSeries_entry);
++ series->setGraph(this);
++ if (m_seriesList.contains(series)) {
++ qsizetype oldIndex = m_seriesList.indexOf(series);
++ if (index != oldIndex) {
++ m_seriesList.removeOne(series);
++ if (oldIndex < index)
++ index--;
++ m_seriesList.insert(index, series);
++ qCDebug(lcGraphs2D, "series was already in seriesList, removed old series at index: %" PRIdQSIZETYPE
++ " and inserted new one at index: %" PRIdQSIZETYPE,
++ oldIndex, index);
++ }
++ } else {
++ m_seriesList.insert(index, series);
++
++ QObject::connect(series,
++ &QAbstractSeries::update,
++ this,
++ &QGraphsView::updateComponentSizes);
++ QObject::connect(series, &QAbstractSeries::update,
++ this, &QGraphsView::polishAndUpdate);
++ QObject::connect(series, &QAbstractSeries::hoverEnter,
++ this, &QGraphsView::handleHoverEnter);
++ QObject::connect(series, &QAbstractSeries::hoverExit,
++ this, &QGraphsView::handleHoverExit);
++ QObject::connect(series, &QAbstractSeries::hover,
++ this, &QGraphsView::handleHover);
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (auto pie = qobject_cast<QPieSeries *>(series))
++ connect(pie, &QPieSeries::removed, m_pieRenderer, &PieRenderer::markedDeleted);
++ #endif
++ #if QT_CONFIG(graphs_2d_bar)
++ if (auto bar = qobject_cast<QBarSeries *>(series); bar && m_barsRenderer) {
++ connect(bar,
++ &QBarSeries::barsetsRemoved,
++ m_barsRenderer,
++ &BarsRenderer::handleBarSetsRemoved);
++ }
++ #endif
++ qCDebug(lcGraphs2D) << series << "added to a list at index of" << index;
++ }
++ Q_TRACE(QGraphs2DGraphsViewInsertSeries_exit);
++
++ updateComponentSizes();
++ polishAndUpdate();
++ }
++ }
++
++ /*!
++ \qmlmethod void GraphsView::removeSeries(AbstractSeries series)
++ Removes the \a series from the graph.
++ */
++ /*!
++ Removes the \a series from the graph.
++ */
++ void QGraphsView::removeSeries(QObject *object)
++ {
++ if (auto series = qobject_cast<QAbstractSeries *>(object)) {
++ detachSeries(series);
++ updateComponentSizes();
++ polishAndUpdate();
++ }
++ }
++
++ void QGraphsView::detachSeries(QAbstractSeries *series)
++ {
++ series->setGraph(nullptr);
++ m_seriesList.removeAll(series);
++ auto &cleanupSeriesList = m_cleanupSeriesList[getSeriesRendererIndex(series)];
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (auto pie = qobject_cast<QPieSeries *>(series))
++ disconnect(pie, &QPieSeries::removed, m_pieRenderer, &PieRenderer::markedDeleted);
++ #endif
++ #if QT_CONFIG(graphs_2d_bar)
++ if (auto bar = qobject_cast<QBarSeries *>(series); bar && m_barsRenderer) {
++ disconnect(bar,
++ &QBarSeries::barsetsRemoved,
++ m_barsRenderer,
++ &BarsRenderer::handleBarSetsRemoved);
++ }
++ #endif
++ qCDebug(lcGraphs2D) << "removing" << series << "from seriesList";
++ cleanupSeriesList.append(series);
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer)
++ m_pointRenderer->seriesAboutToBeRemoved(series);
++ #endif
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer)
++ m_barsRenderer->seriesAboutToBeRemoved(series);
++ #endif
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer)
++ m_pieRenderer->seriesAboutToBeRemoved(series);
++ #endif
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer)
++ m_areaRenderer->seriesAboutToBeRemoved(series);
++ #endif
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer)
++ m_customRenderer->seriesAboutToBeRemoved(series);
++ #endif
++ }
++
++ /*!
++ \qmlmethod void GraphsView::removeSeries(int index)
++ Removes the series specified by \a index from the graph.
++ */
++ /*!
++ Removes the series specified by \a index from the graph.
++ */
++ void QGraphsView::removeSeries(qsizetype index)
++ {
++ if (index >= 0 && index < m_seriesList.size())
++ removeSeries(m_seriesList[index]);
++ }
++
++ /*!
++ \qmlmethod bool GraphsView::hasSeries(AbstractSeries series)
++ Returns \c true if the \a series is in the graph.
++ */
++ /*!
++ Returns \c true if the \a series is in the graph.
++ */
++ bool QGraphsView::hasSeries(QObject *series)
++ {
++ return m_seriesList.contains(series);
++ }
++
++ QPointF QGraphsView::getDataPointCoordinates(QAbstractSeries *series, qreal x, qreal y)
++ {
++ #if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
++ if (m_pointRenderer)
++ return m_pointRenderer->reverseRenderCoordinates(series, x, y);
++ #else
++ Q_UNUSED(series);
++ Q_UNUSED(x);
++ Q_UNUSED(y);
++ #endif
++ return QPointF();
++ }
++
++ bool QGraphsView::isSeriesSupported(QObject *series) const
++ {
++ Q_UNUSED(series);
++ return true;
++ }
++
++ bool QGraphsView::addAxis(QAbstractAxis *axis)
++ {
++ if (axis) {
++ axis->d_func()->setGraph(this);
++ // Ensure AxisRenderer exists
++ createAxisRenderer();
++ polishAndUpdate();
++ QObject::connect(axis, &QAbstractAxis::update, this, &QGraphsView::polishAndUpdate);
++ QObject::connect(axis, &QAbstractAxis::update, this, &QGraphsView::updateComponentSizes);
++ return true;
++ }
++ return false;
++ }
++
++ void QGraphsView::removeAxis(QAbstractAxis *axis, bool removeAllReferences)
++ {
++ if (axis) {
++ axis->d_func()->setGraph(nullptr);
++ QObject::disconnect(axis, &QAbstractAxis::update, this, &QGraphsView::polishAndUpdate);
++ QObject::disconnect(axis,
++ &QAbstractAxis::update,
++ this,
++ &QGraphsView::updateComponentSizes);
++ }
++
++ if (m_axisX == axis)
++ m_axisX = nullptr;
++ if (m_axisY == axis)
++ m_axisY = nullptr;
++
++ if (removeAllReferences) {
++ for (auto&& s : m_seriesList) {
++ if (auto series = qobject_cast<QAbstractSeries *>(s))
++ series->d_func()->removeAxis(axis);
++ }
++ }
++
++ updateComponentSizes();
++ polishAndUpdate();
++ }
++
++ qsizetype QGraphsView::graphSeriesCount() const
++ {
++ return m_graphSeriesCount;
++ }
++
++ void QGraphsView::setGraphSeriesCount(qsizetype count)
++ {
++ if (count > m_graphSeriesCount)
++ m_graphSeriesCount = count;
++ }
++
++ #if QT_CONFIG(graphs_2d_bar)
++ void QGraphsView::createBarsRenderer()
++ {
++ Q_TRACE_SCOPE(QGraphs2DGraphsViewCreateBarsRenderer);
++ if (!m_barsRenderer) {
++ qCDebug(lcGraphs2D, "creating bars renderer");
++ m_barsRenderer = new BarsRenderer(this, clipPlotArea());
++ updateComponentSizes();
++ }
++ }
++ #endif
++
++ void QGraphsView::createAxisRenderer()
++ {
++ Q_TRACE_SCOPE(QGraphs2DGraphsViewCreateAxisRenderer);
++ if (!m_axisRenderer) {
++ qCDebug(lcGraphs2D) << "creating axis renderer.";
++ m_axisRenderer = new AxisRenderer(this);
++ m_axisRenderer->setZ(-1);
++ updateComponentSizes();
++ }
++ }
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ void QGraphsView::createPointRenderer()
++ {
++ Q_TRACE_SCOPE(QGraphs2DGraphsViewCreatePointRenderer);
++ if (!m_pointRenderer) {
++ qCDebug(lcGraphs2D, "creating point renderer.");
++ m_pointRenderer = new PointRenderer(this, clipPlotArea());
++ updateComponentSizes();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ void QGraphsView::createPieRenderer()
++ {
++ Q_TRACE_SCOPE(QGraphs2DGraphsViewCreatePieRenderer);
++ if (!m_pieRenderer) {
++ qCDebug(lcGraphs2D, "creating pie renderer.");
++ m_pieRenderer = new PieRenderer(this, clipPlotArea());
++ updateComponentSizes();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ void QGraphsView::createAreaRenderer()
++ {
++ Q_TRACE_SCOPE(QGraphs2DGraphsViewCreateAreaRenderer);
++ if (!m_areaRenderer) {
++ qCDebug(lcGraphs2D, "creating area renderer.");
++ m_areaRenderer = new AreaRenderer(this, clipPlotArea());
++ updateComponentSizes();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_custom)
++ void QGraphsView::createCustomRenderer()
++ {
++ if (!m_customRenderer) {
++ qCDebug(lcGraphs2D, "creating custom renderer.");
++ m_customRenderer = new CustomRenderer(this, clipPlotArea());
++ updateComponentSizes();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ void QGraphsView::createCanvasPainter()
++ {
++ if (!m_painterItem) {
++ qCDebug(lcGraphs2D, "creating canvas painter item.");
++ m_painterItem = new QCPainterItem(m_areaRenderer, m_barsRenderer, m_pieRenderer,
++ m_pointRenderer, m_customRenderer, this);
++ m_painterItem->setAlphaBlending(true);
++ m_painterItem->setFillColor(Qt::transparent);
++ m_painterItem->setAntialiasing(true);
++
++ if (m_initialized)
++ updateComponentSizes();
++ }
++ }
++
++ void QGraphsView::removeCanvasPainter()
++ {
++ if (m_painterItem) {
++ m_painterItem->deleteLater();
++ m_painterItem = nullptr;
++ }
++ }
++ #endif
++
++ /*!
++ \property QGraphsView::axisXSmoothing
++ \brief Controls the graph X axis smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::axisXSmoothing
++ Controls the graph X axis smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ qreal QGraphsView::axisXSmoothing() const
++ {
++ return m_axisXSmoothing;
++ }
++
++ void QGraphsView::setAxisXSmoothing(qreal smoothing)
++ {
++ if (QtPrivate::fuzzyCompare(m_axisXSmoothing, smoothing)) {
++ qCDebug(lcViewProperties2D, "%s axis smoothing is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)),
++ smoothing);
++ return;
++ }
++ m_axisXSmoothing = smoothing;
++ emit axisXSmoothingChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::axisYSmoothing
++ \brief Controls the graph Y axis smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::axisYSmoothing
++ Controls the graph Y axis smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ qreal QGraphsView::axisYSmoothing() const
++ {
++ return m_axisYSmoothing;
++ }
++
++ void QGraphsView::setAxisYSmoothing(qreal smoothing)
++ {
++ if (QtPrivate::fuzzyCompare(m_axisYSmoothing, smoothing)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), smoothing);
++ return;
++ }
++ m_axisYSmoothing = smoothing;
++ emit axisYSmoothingChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::gridSmoothing
++ \brief Controls the graph grid smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::gridSmoothing
++ Controls the graph grid smoothing (antialiasing) amount.
++ By default, the smoothing is \c 1.0.
++ */
++ qreal QGraphsView::gridSmoothing() const
++ {
++ return m_gridSmoothing;
++ }
++
++ void QGraphsView::setGridSmoothing(qreal smoothing)
++ {
++ if (QtPrivate::fuzzyCompare(m_gridSmoothing, smoothing)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), smoothing);
++ return;
++ }
++ m_gridSmoothing = smoothing;
++ emit gridSmoothingChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowVisible
++ \brief Controls if the graph grid shadow is visible.
++ By default, shadow visibility is set to \c false.
++ */
++ /*!
++ \qmlproperty bool GraphsView::shadowVisible
++ Controls if the graph grid shadow is visible.
++ By default, shadow visibility is set to \c false.
++ */
++ bool QGraphsView::isShadowVisible() const
++ {
++ return m_isShadowVisible;
++ }
++
++ void QGraphsView::setShadowVisible(bool newShadowVisibility)
++ {
++ if (m_isShadowVisible == newShadowVisibility) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newShadowVisibility;
++ return;
++ }
++ m_isShadowVisible = newShadowVisibility;
++ emit shadowVisibleChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowColor
++ \brief Controls the graph grid shadow color.
++ By default, shadow color is set to \c black.
++ */
++ /*!
++ \qmlproperty color GraphsView::shadowColor
++ Controls the graph grid shadow color.
++ By default, shadow color is set to \c black.
++ */
++ QColor QGraphsView::shadowColor() const
++ {
++ return m_shadowColor;
++ }
++
++ void QGraphsView::setShadowColor(QColor newShadowColor)
++ {
++ if (m_shadowColor == newShadowColor) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %s",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), qUtf8Printable(newShadowColor.name()));
++ return;
++ }
++ m_shadowColor = newShadowColor;
++ emit shadowColorChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowBarWidth
++ \brief Controls the graph grid shadow width.
++ By default, shadow width is set to \c 2.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::shadowBarWidth
++ Controls the graph grid shadow width.
++ By default, shadow width is set to \c 2.0.
++ */
++ qreal QGraphsView::shadowBarWidth() const
++ {
++ return m_shadowBarWidth;
++ }
++
++ void QGraphsView::setShadowBarWidth(qreal newShadowBarWidth)
++ {
++ if (QtPrivate::fuzzyCompare(m_shadowBarWidth, newShadowBarWidth)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newShadowBarWidth);
++ return;
++ }
++ m_shadowBarWidth = newShadowBarWidth;
++ emit shadowBarWidthChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowXOffset
++ \brief Controls the graph grid shadow X offset.
++ By default, shadow X offset is set to \c 0.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::shadowXOffset
++ Controls the graph grid shadow X offset.
++ By default, shadow X offset is set to \c 0.0.
++ */
++ qreal QGraphsView::shadowXOffset() const
++ {
++ return m_shadowXOffset;
++ }
++
++ void QGraphsView::setShadowXOffset(qreal newShadowXOffset)
++ {
++ if (QtPrivate::fuzzyCompare(m_shadowXOffset, newShadowXOffset)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newShadowXOffset);
++ return;
++ }
++ m_shadowXOffset = newShadowXOffset;
++ emit shadowXOffsetChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowYOffset
++ \brief Controls the graph grid shadow Y offset.
++ By default, shadow Y offset is set to \c 0.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::shadowYOffset
++ Controls the graph grid shadow Y offset.
++ By default, shadow Y offset is set to \c 0.0.
++ */
++ qreal QGraphsView::shadowYOffset() const
++ {
++ return m_shadowYOffset;
++ }
++
++ void QGraphsView::setShadowYOffset(qreal newShadowYOffset)
++ {
++ if (QtPrivate::fuzzyCompare(m_shadowYOffset, newShadowYOffset)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newShadowYOffset);
++ return;
++ }
++ m_shadowYOffset = newShadowYOffset;
++ emit shadowYOffsetChanged();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::shadowSmoothing
++ \brief Controls the graph grid shadow smoothing (antialiasing) amount.
++ By default, shadow smoothing is set to \c 4.0.
++ */
++ /*!
++ \qmlproperty real GraphsView::shadowSmoothing
++ Controls the graph grid shadow smoothing (antialiasing) amount.
++ By default, shadow smoothing is set to \c 4.0.
++ */
++ qreal QGraphsView::shadowSmoothing() const
++ {
++ return m_shadowSmoothing;
++ }
++
++ void QGraphsView::setShadowSmoothing(qreal smoothing)
++ {
++ if (QtPrivate::fuzzyCompare(m_shadowSmoothing, smoothing)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), smoothing);
++ return;
++ }
++ m_shadowSmoothing = smoothing;
++ emit shadowSmoothingChanged();
++ polishAndUpdate();
++ }
++
++ void QGraphsView::handleHoverEnter(const QString &seriesName, QPointF position, QPointF value)
++ {
++ if (m_hoverCount == 0)
++ emit hoverEnter(seriesName, position, value);
++ m_hoverCount++;
++ }
++
++ void QGraphsView::handleHoverExit(const QString &seriesName, QPointF position)
++ {
++ m_hoverCount--;
++ if (m_hoverCount == 0)
++ emit hoverExit(seriesName, position);
++ }
++
++ void QGraphsView::handleHover(const QString &seriesName, QPointF position, QPointF value)
++ {
++ emit hover(seriesName, position, value);
++ }
++
++ void QGraphsView::updateComponentSizes()
++ {
++ qCDebug(lcEvents2D, "updating component sizes.");
++
++ if (m_axisRenderer)
++ m_axisRenderer->updateAxisMeasurements();
++
++ updateAxisAreas();
++ updatePlotArea();
++
++ if (m_axisRenderer)
++ m_axisRenderer->setSize(size());
++
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer) {
++ m_barsRenderer->setX(m_plotArea.x());
++ m_barsRenderer->setY(m_plotArea.y());
++ m_barsRenderer->setSize(m_plotArea.size());
++ qCDebug(lcEvents2D) << "bars graph size:" << m_plotArea.size();
++ qCDebug(lcEvents2D, "barsRenderer plotArea x: %f y: %f",
++ m_plotArea.x(),
++ m_plotArea.y());
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer) {
++ m_pointRenderer->setX(m_plotArea.x());
++ m_pointRenderer->setY(m_plotArea.y());
++ m_pointRenderer->setSize(m_plotArea.size());
++ qCDebug(lcEvents2D) << "point graph size:" << m_plotArea.size();
++ qCDebug(lcEvents2D, "pointRenderer plotArea x: %f y: %f",
++ m_plotArea.x(),
++ m_plotArea.y());
++
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer) {
++ m_pieRenderer->setX(m_plotArea.x());
++ m_pieRenderer->setY(m_plotArea.y());
++ m_pieRenderer->setSize(m_plotArea.size());
++ qCDebug(lcEvents2D) << "pie graph size:" << m_plotArea.size();
++ qCDebug(lcEvents2D, "pieRenderer plotArea x: %f y: %f",
++ m_plotArea.x(),
++ m_plotArea.y());
++
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer) {
++ m_areaRenderer->setX(m_plotArea.x());
++ m_areaRenderer->setY(m_plotArea.y());
++ m_areaRenderer->setSize(m_plotArea.size());
++ qCDebug(lcEvents2D) << "area graph size:" << m_plotArea.size();
++ qCDebug(lcEvents2D, "areaRenderer plotArea x: %f y: %f",
++ m_plotArea.x(),
++ m_plotArea.y());
++
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer) {
++ m_customRenderer->setX(m_plotArea.x());
++ m_customRenderer->setY(m_plotArea.y());
++ m_customRenderer->setSize(m_plotArea.size());
++ qCDebug(lcEvents2D) << "custom graph size:" << m_plotArea.size();
++ qCDebug(lcEvents2D, "customaRenderer plotArea x: %f y: %f", m_plotArea.x(), m_plotArea.y());
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ if (m_painterItem) {
++ m_painterItem->setX(m_plotArea.x());
++ m_painterItem->setY(m_plotArea.y());
++ m_painterItem->setSize(m_plotArea.size());
++ }
++ #endif
++ }
++
++ void QGraphsView::componentComplete()
++ {
++ Q_TRACE(QGraphs2DGraphsViewComponentComplete_entry);
++ if (!m_zoomAreaDelegate && !m_zoomAreaItem) {
++
++ QQmlComponent tempZoomAreaDelegate(qmlEngine(this));
++ tempZoomAreaDelegate.loadFromModule(u"QtGraphs2D.impl"_s, u"ZoomAreaDelegate"_s);
++
++ m_zoomAreaItem = qobject_cast<QQuickItem *>(
++ tempZoomAreaDelegate.create(tempZoomAreaDelegate.creationContext()));
++ m_zoomAreaItem->setParent(this);
++ m_zoomAreaItem->setParentItem(this);
++ m_zoomAreaItem->setVisible(false);
++ }
++
++ if (!m_theme) {
++ m_theme = m_defaultTheme;
++ QObject::connect(m_theme, &QGraphsTheme::update, this, &QQuickItem::update);
++ QObject::connect(m_theme, &QGraphsTheme::update,
++ this, &QGraphsView::updateComponentSizes);
++ m_theme->resetColorTheme();
++ // resetColorTheme() only emits QGraphsTheme::update (and thus triggers
++ // updateComponentSizes()) if the theme actually changes, which it doesn't
++ // here since QtGreen is already the default. Recompute axis margins
++ // explicitly so they don't stay at their stale, theme-less construction-time
++ // values for the first frame.
++ if (m_axisRenderer)
++ updateComponentSizes();
++ }
++ Q_TRACE(QGraphs2DGraphsViewComponentComplete_exit);
++
++ QQuickItem::componentComplete();
++
++ qCDebug(lcEvents2D, "QGraphsView::componentComplete.");
++
++ ensurePolished();
++ }
++
++ void QGraphsView::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
++ {
++ qCDebug(lcEvents2D) << "QGraphsView::geometryChange."
++ << "oldGeometry:" << oldGeometry
++ << "newGeometry:" << newGeometry;
++
++ QQuickItem::geometryChange(newGeometry, oldGeometry);
++
++ updateComponentSizes();
++
++ ensurePolished();
++ }
++
++ void QGraphsView::hoverMoveEvent(QHoverEvent *event)
++ {
++ bool handled = false;
++
++ // Adjust event position to renderers position
++ QPointF localPos = event->position() - m_plotArea.topLeft();
++ QHoverEvent mappedEvent(event->type(), localPos,event->globalPosition(),
++ event->oldPosF(), event->modifiers());
++ mappedEvent.setAccepted(false);
++
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer)
++ handled |= m_barsRenderer->handleHoverMove(&mappedEvent);
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer)
++ handled |= m_pointRenderer->handleHoverMove(&mappedEvent);
++ #endif
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer)
++ handled |= m_pieRenderer->handleHoverMove(&mappedEvent);
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer)
++ handled |= m_areaRenderer->handleHoverMove(&mappedEvent);
++ #endif
++
++ if (!handled)
++ event->ignore();
++ }
++
++ void QGraphsView::wheelEvent(QWheelEvent *event)
++ {
++ bool handled = false;
++
++ // Adjust event position to renderers position
++ QPointF localPos = event->position() - m_plotArea.topLeft();
++ QWheelEvent mappedEvent(localPos,
++ event->globalPosition(),
++ event->pixelDelta(),
++ event->angleDelta(),
++ event->buttons(),
++ event->modifiers(),
++ event->phase(),
++ event->inverted(),
++ event->source());
++ mappedEvent.setAccepted(false);
++
++ if (m_axisRenderer)
++ handled |= m_axisRenderer->handleWheel(&mappedEvent);
++
++ if (!handled)
++ event->ignore();
++ else
++ polishAndUpdate();
++ }
++
++ QSGNode *QGraphsView::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *updatePaintNodeData)
++ {
++ Q_UNUSED(updatePaintNodeData);
++
++ for (auto series : std::as_const(m_seriesList)) {
++ qCDebug(lcEvents2D) << "QGraphsView::updatePaintNode." << series;
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer) {
++ if (auto barSeries = qobject_cast<QBarSeries *>(series))
++ m_barsRenderer->updateSeries(barSeries);
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer) {
++ #if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
++ if (auto lineSeries = qobject_cast<QLineSeries *>(series))
++ m_pointRenderer->updateSeries(lineSeries);
++ #endif
++ #if QT_CONFIG(graphs_2d_scatter)
++ if (auto scatterSeries = qobject_cast<QScatterSeries *>(series))
++ m_pointRenderer->updateSeries(scatterSeries);
++ #endif
++ #if QT_CONFIG(graphs_2d_spline)
++ if (auto splineSeries = qobject_cast<QSplineSeries *>(series))
++ m_pointRenderer->updateSeries(splineSeries);
++ #endif
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer) {
++ if (auto pieSeries = qobject_cast<QPieSeries *>(series))
++ m_pieRenderer->updateSeries(pieSeries);
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer) {
++ if (auto areaSeries = qobject_cast<QAreaSeries *>(series))
++ m_areaRenderer->updateSeries(areaSeries);
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer) {
++ if (auto customSeries = qobject_cast<QCustomSeries *>(series))
++ m_customRenderer->updateSeries(customSeries);
++ }
++ #endif
++ }
++
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[0];
++ m_barsRenderer->afterUpdate(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[1];
++ m_pointRenderer->afterUpdate(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[2];
++ m_areaRenderer->afterUpdate(cleanupSeriesList);
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[3];
++ m_pieRenderer->afterUpdate(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[4];
++ m_customRenderer->afterUpdate(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ }
++ #endif
++
++ // Now possibly dirty theme has been taken into use
++ m_theme->resetThemeDirty();
++
++ return oldNode;
++ }
++
++ void QGraphsView::updatePolish()
++ {
++ qCDebug(lcEvents2D, "QGraphsView::updatePolish. Start Update and polish.");
++
++ Q_TRACE_SCOPE(QGraphs2DGraphsVieUpdatePolish);
++ if (m_axisRenderer) {
++ m_axisRenderer->handlePolish();
++ // Initialize shaders after system's event queue
++ QTimer::singleShot(0, m_axisRenderer, &AxisRenderer::initialize);
++ }
++ if (m_theme && m_theme->isBackgroundVisible()) {
++ if (!m_backgroundRectangle) {
++ // Create m_backgroundRectangle only when it is needed
++ m_backgroundRectangle = new QQuickRectangle(this);
++ m_backgroundRectangle->setZ(-2);
++ }
++ m_backgroundRectangle->setColor(m_theme->backgroundColor());
++ m_backgroundRectangle->setWidth(width());
++ m_backgroundRectangle->setHeight(height());
++ m_backgroundRectangle->setVisible(true);
++ } else if (m_backgroundRectangle) {
++ // Hide and delete the m_backgroundRectangle
++ m_backgroundRectangle->setVisible(false);
++ m_backgroundRectangle->deleteLater();
++ m_backgroundRectangle = nullptr;
++ }
++
++ std::sort(m_seriesList.begin(), m_seriesList.end(), [](QObject *lhs, QObject *rhs) {
++ auto series1 = qobject_cast<QAbstractSeries *>(lhs);
++ auto series2 = qobject_cast<QAbstractSeries *>(rhs);
++
++ if (series1 && series2)
++ return series1->zValue() < series2->zValue();
++ return false;
++ });
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer)
++ m_pointRenderer->resetShapePathCount();
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer)
++ m_areaRenderer->resetShapePathCount();
++ #endif
++
++
++ // Polish for all series
++ #if QT_CONFIG(graphs_2d_bar)
++ float highestBarsZ = std::numeric_limits<float>::lowest();
++ int barSeriesIndex = 0;
++ int barSeriesCount =
++ std::count_if(m_seriesList.begin(), m_seriesList.end(),
++ [](const auto &series) { return qobject_cast<QBarSeries *>(series); });
++ #endif
++ for (auto series : std::as_const(m_seriesList)) {
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer) {
++ if (auto barSeries = qobject_cast<QBarSeries *>(series)) {
++ m_barsRenderer->handlePolish(barSeries, barSeriesIndex, barSeriesCount);
++ if (barSeries->zValue() > highestBarsZ)
++ highestBarsZ = barSeries->zValue();
++ barSeriesIndex++;
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ float highestPointZ = std::numeric_limits<float>::lowest();
++
++ if (m_pointRenderer) {
++ #if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
++ if (auto lineSeries = qobject_cast<QLineSeries *>(series)) {
++ m_pointRenderer->handlePolish(lineSeries);
++ if (lineSeries->zValue() > highestPointZ)
++ highestPointZ = lineSeries->zValue();
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_scatter)
++ if (auto scatterSeries = qobject_cast<QScatterSeries *>(series)) {
++ m_pointRenderer->handlePolish(scatterSeries);
++ if (scatterSeries->zValue() > highestPointZ)
++ highestPointZ = scatterSeries->zValue();
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_spline)
++ if (auto splineSeries = qobject_cast<QSplineSeries *>(series)) {
++ m_pointRenderer->handlePolish(splineSeries);
++ if (splineSeries->zValue() > highestPointZ)
++ highestPointZ = splineSeries->zValue();
++ }
++ #endif
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ float highestPieZ = std::numeric_limits<float>::lowest();
++
++ if (m_pieRenderer) {
++ if (auto pieSeries = qobject_cast<QPieSeries *>(series)) {
++ m_pieRenderer->handlePolish(pieSeries);
++ if (pieSeries->zValue() > highestPieZ)
++ highestPieZ = pieSeries->zValue();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_area)
++ float highestAreaZ = std::numeric_limits<float>::lowest();
++
++ if (m_areaRenderer) {
++ if (auto areaSeries = qobject_cast<QAreaSeries *>(series)) {
++ m_areaRenderer->handlePolish(areaSeries);
++ if (areaSeries->zValue() > highestAreaZ)
++ highestAreaZ = areaSeries->zValue();
++ }
++ }
++ #endif
++
++ #if QT_CONFIG(graphs_2d_custom)
++ float highestCustomZ = std::numeric_limits<float>::lowest();
++
++ if (m_customRenderer) {
++ if (auto customSeries = qobject_cast<QCustomSeries *>(series)) {
++ m_customRenderer->handlePolish(customSeries);
++ if (customSeries->zValue() > highestCustomZ)
++ highestCustomZ = customSeries->zValue();
++ }
++ }
++ #endif
++ }
++
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer) {
++ auto &cleanupSeriesList = m_cleanupSeriesList[0];
++ m_barsRenderer->afterPolish(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ if (highestBarsZ > std::numeric_limits<float>::lowest())
++ m_barsRenderer->setZ(highestBarsZ);
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer) {
++ float highestPointZ = std::numeric_limits<float>::lowest();
++
++ auto &cleanupSeriesList = m_cleanupSeriesList[1];
++ m_pointRenderer->afterPolish(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ if (highestPointZ > std::numeric_limits<float>::lowest())
++ m_pointRenderer->setZ(highestPointZ);
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer) {
++ float highestAreaZ = std::numeric_limits<float>::lowest();
++
++ auto &cleanupSeriesList = m_cleanupSeriesList[2];
++ m_areaRenderer->afterPolish(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ if (highestAreaZ > std::numeric_limits<float>::lowest())
++ m_areaRenderer->setZ(highestAreaZ);
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer) {
++ float highestPieZ = std::numeric_limits<float>::lowest();
++
++ auto &cleanupSeriesList = m_cleanupSeriesList[3];
++ m_pieRenderer->afterPolish(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ if (highestPieZ > std::numeric_limits<float>::lowest())
++ m_pieRenderer->setZ(highestPieZ);
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer) {
++ float highestCustomZ = std::numeric_limits<float>::lowest();
++
++ auto &cleanupSeriesList = m_cleanupSeriesList[4];
++ m_customRenderer->afterPolish(cleanupSeriesList);
++ cleanupSeriesList.clear();
++ if (highestCustomZ > std::numeric_limits<float>::lowest())
++ m_customRenderer->setZ(highestCustomZ);
++ }
++ #endif
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ if (m_painterItem)
++ m_painterItem->update();
++ #endif
++ }
++
++ void QGraphsView::polishAndUpdate()
++ {
++ polish();
++ update();
++ }
++
++ // ***** Static QQmlListProperty methods *****
++
++ /*!
++ \qmlproperty list GraphsView::seriesList
++
++ List of series that are rendered by the GraphsView. Filled automatically
++ with the series type children of the GraphsView.
++
++ This is the default property, so child elements are automatically added
++ into the series list.
++ \sa BarSeries, LineSeries, ScatterSeries
++ */
++ QQmlListProperty<QObject> QGraphsView::seriesList()
++ {
++ return QQmlListProperty<QObject>(this, this,
++ &QGraphsView::appendSeriesFunc,
++ &QGraphsView::countSeriesFunc,
++ &QGraphsView::atSeriesFunc,
++ &QGraphsView::clearSeriesFunc);
++ }
++
++ void QGraphsView::appendSeriesFunc(QQmlListProperty<QObject> *list, QObject *series)
++ {
++ reinterpret_cast<QGraphsView *>(list->data)->addSeries(series);
++ }
++
++ qsizetype QGraphsView::countSeriesFunc(QQmlListProperty<QObject> *list)
++ {
++ return reinterpret_cast<QGraphsView *>(list->data)->getSeriesList().size();
++ }
++
++ QObject *QGraphsView::atSeriesFunc(QQmlListProperty<QObject> *list, qsizetype index)
++ {
++ return reinterpret_cast<QGraphsView *>(list->data)->getSeriesList().at(index);
++ }
++
++ void QGraphsView::clearSeriesFunc(QQmlListProperty<QObject> *list)
++ {
++ QGraphsView *declItems = reinterpret_cast<QGraphsView *>(list->data);
++ QList<QObject *> realList = declItems->getSeriesList();
++ qsizetype count = realList.size();
++ for (int i = 0; i < count; i++)
++ declItems->removeSeries(realList.at(i));
++ }
++
++ /*!
++ \qmlproperty GraphsTheme GraphsView::theme
++ The theme used by the graph. Determines coloring,
++ axis lines, fonts etc. If theme has not been set,
++ the default theme is used.
++ */
++ QGraphsTheme *QGraphsView::theme() const
++ {
++ return m_theme;
++ }
++
++ void QGraphsView::setTheme(QGraphsTheme *newTheme)
++ {
++ if (m_theme == newTheme) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "theme is already set to:" << newTheme;
++ return;
++ }
++
++ if (m_theme)
++ QObject::disconnect(m_theme, nullptr, this, nullptr);
++
++ m_theme = newTheme;
++
++ if (!m_theme) {
++ m_theme = m_defaultTheme;
++ m_theme->resetColorTheme();
++ }
++
++ QObject::connect(m_theme, &QGraphsTheme::update, this, &QGraphsView::polishAndUpdate);
++ QObject::connect(m_theme, &QGraphsTheme::update,
++ this, &QGraphsView::updateComponentSizes);
++ emit themeChanged();
++ updateComponentSizes();
++ polishAndUpdate();
++ }
++
++ /*!
++ \qmlproperty real GraphsView::marginTop
++ The amount of empty space on the top of the graph.
++ By default, the margin is 20.
++ */
++ qreal QGraphsView::marginTop() const
++ {
++ return m_marginTop;
++ }
++
++ void QGraphsView::setMarginTop(qreal newMarginTop)
++ {
++ if (QtPrivate::fuzzyCompare(m_marginTop, newMarginTop)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newMarginTop);
++ return;
++ }
++ m_marginTop = newMarginTop;
++ updateComponentSizes();
++ polishAndUpdate();
++ emit marginTopChanged();
++ }
++
++ /*!
++ \qmlproperty real GraphsView::marginBottom
++ The amount of empty space on the bottom of the graph.
++ By default, the margin is 20.
++ */
++ qreal QGraphsView::marginBottom() const
++ {
++ return m_marginBottom;
++ }
++
++ void QGraphsView::setMarginBottom(qreal newMarginBottom)
++ {
++ if (QtPrivate::fuzzyCompare(m_marginBottom, newMarginBottom)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newMarginBottom);
++ return;
++ }
++ m_marginBottom = newMarginBottom;
++ updateComponentSizes();
++ polishAndUpdate();
++ emit marginBottomChanged();
++ }
++
++ /*!
++ \qmlproperty real GraphsView::marginLeft
++ The amount of empty space on the left of the graph.
++ By default, the margin is 20.
++ */
++ qreal QGraphsView::marginLeft() const
++ {
++ return m_marginLeft;
++ }
++
++ void QGraphsView::setMarginLeft(qreal newMarginLeft)
++ {
++ if (QtPrivate::fuzzyCompare(m_marginLeft, newMarginLeft)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newMarginLeft);
++ return;
++ }
++ m_marginLeft = newMarginLeft;
++ updateComponentSizes();
++ polishAndUpdate();
++ emit marginLeftChanged();
++ }
++
++ /*!
++ \qmlproperty real GraphsView::marginRight
++ The amount of empty space on the right of the graph.
++ By default, the margin is 20.
++ */
++ qreal QGraphsView::marginRight() const
++ {
++ return m_marginRight;
++ }
++
++ void QGraphsView::setMarginRight(qreal newMarginRight)
++ {
++ if (QtPrivate::fuzzyCompare(m_marginRight, newMarginRight)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newMarginRight);
++ return;
++ }
++ m_marginRight = newMarginRight;
++ updateComponentSizes();
++ polishAndUpdate();
++ emit marginRightChanged();
++ }
++
++ /*!
++ \property QGraphsView::clipPlotArea
++ \since 6.10
++ \brief Controls whether graph items should be clipped
++ if they go outside of a plot area. The default value is \c true.
++
++ \sa QGraphsView::plotArea
++ */
++ /*!
++ \qmlproperty bool GraphsView::clipPlotArea
++ \since 6.10
++ Controls whether graph items should be clipped
++ if they go outside of a plot area. The default value is \c true.
++
++ \sa plotArea
++ */
++ bool QGraphsView::clipPlotArea() const
++ {
++ return m_clipPlotArea;
++ }
++
++ void QGraphsView::setClipPlotArea(bool enabled)
++ {
++ if (m_clipPlotArea == enabled) {
++ qCDebug(lcViewProperties2D, "QGraphsView::setClipPlotArea is already set to %d",
++ enabled);
++ return;
++ }
++
++ m_clipPlotArea = enabled;
++ emit clipPlotAreaChanged();
++ #if QT_CONFIG(graphs_2d_area) || QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_scatter) || QT_CONFIG(graphs_2d_spline)
++ if (m_pointRenderer)
++ m_pointRenderer->setClip(m_clipPlotArea);
++ #endif
++ #if QT_CONFIG(graphs_2d_area)
++ if (m_areaRenderer)
++ m_areaRenderer->setClip(m_clipPlotArea);
++ #endif
++ #if QT_CONFIG(graphs_2d_donut_pie)
++ if (m_pieRenderer)
++ m_pieRenderer->setClip(m_clipPlotArea);
++ #endif
++ #if QT_CONFIG(graphs_2d_bar)
++ if (m_barsRenderer)
++ m_barsRenderer->setClip(m_clipPlotArea);
++ #endif
++ #if QT_CONFIG(graphs_2d_custom)
++ if (m_customRenderer)
++ m_customRenderer->setClip(m_clipPlotArea);
++ #endif
++ }
++
++ /*!
++ \property QGraphsView::plotArea
++ \since 6.9
++ \brief The rectangle within which the graph is drawn.
++
++ This is the QGraphsView area minus axis areas and margins.
++ \sa marginTop, marginBottom, marginLeft, marginRight
++ */
++ /*!
++ \qmlproperty rect GraphsView::plotArea
++ \since 6.9
++ The rectangle within which the graph is drawn.
++ This is the GraphsView area minus axis areas and margins.
++ \sa marginTop, marginBottom, marginLeft, marginRight
++ */
++ QRectF QGraphsView::plotArea() const
++ {
++ return m_plotArea;
++ }
++
++ QGraphsView::AxisSizes QGraphsView::axisSizes() const
++ {
++ if (!m_axisRenderer)
++ return {};
++ return {m_axisRenderer->m_y1AxisWidth,
++ m_axisRenderer->m_y2AxisWidth,
++ m_axisRenderer->m_x1AxisHeight,
++ m_axisRenderer->m_x2AxisHeight};
++ }
++
++ void QGraphsView::updateAxisAreas()
++ {
++ const AxisSizes axes = axisSizes();
++
++ QRectF r = { m_marginLeft,
++ m_marginTop,
++ width() - m_marginLeft - m_marginRight,
++ height() - m_marginTop - m_marginBottom };
++
++ const qreal plotWidth = r.width() - axes.y1 - axes.y2;
++ const qreal plotHeight = r.height() - axes.x1 - axes.x2;
++
++ m_x1AxisArea = {r.x() + axes.y1,
++ r.y() + r.height() - axes.x1,
++ plotWidth,
++ axes.x1};
++
++ m_x2AxisArea = {r.x() + axes.y1,
++ r.y(),
++ plotWidth,
++ axes.x2};
++
++ m_y1AxisArea = {r.x(),
++ r.y() + axes.x2,
++ axes.y1,
++ plotHeight};
++
++ m_y2AxisArea = {r.x() + r.width() - axes.y2,
++ r.y() + axes.x2,
++ axes.y2,
++ plotHeight};
++ }
++
++ void QGraphsView::updatePlotArea()
++ {
++ const AxisSizes axes = axisSizes();
++
++ // When axis are in left & bottom
++ qreal x = m_marginLeft;
++ qreal y = m_marginTop;
++ qreal w = width() - x - m_marginRight;
++ qreal h = height() - y - m_marginBottom;
++
++ y += axes.x2;
++ x += axes.y1;
++ h -= axes.x1 + axes.x2;
++ w -= axes.y1 + axes.y2;
++
++ w = qMax(w, 0.0);
++ h = qMax(h, 0.0);
++ QRectF plotArea = QRectF(x, y, w, h);
++ if (plotArea != m_plotArea) {
++ m_plotArea = plotArea;
++ emit plotAreaChanged();
++ }
++ }
++
++ /*!
++ \property QGraphsView::axisX
++ \brief X-axis of this view.
++
++ The x-axis used for the series inside this view.
++
++ \note Setting the same axis to multiple QGraphsViews is not supported.
++ */
++ /*!
++ \qmlproperty AbstractAxis GraphsView::axisX
++ The x-axis used for the series inside this view.
++ \sa axisY
++
++ \note Setting the same axis to multiple GraphsViews is not supported.
++ */
++
++ QAbstractAxis *QGraphsView::axisX() const
++ {
++ return m_axisX;
++ }
++
++ void QGraphsView::setAxisX(QAbstractAxis *axis)
++ {
++ if (m_axisX == axis) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << axis;
++ return;
++ }
++ if (m_axisX)
++ removeAxis(m_axisX);
++ if (axis) {
++ if (axis->alignment() != Qt::AlignBottom && axis->alignment() != Qt::AlignTop)
++ axis->setAlignment(Qt::AlignBottom);
++ if (!addAxis(axis))
++ axis = nullptr;
++ }
++ m_axisX = axis;
++ updateComponentSizes();
++ emit axisXChanged();
++ update();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::axisY
++ \brief Y-axis of this view.
++
++ The y-axis used for the series inside this view.
++
++ \note Setting the same axis to multiple QGraphsViews is not supported.
++ */
++ /*!
++ \qmlproperty AbstractAxis GraphsView::axisY
++ The y-axis used for the series inside this view.
++ \sa axisX
++
++ \note Setting the same axis to multiple GraphsViews is not supported.
++ */
++
++ QAbstractAxis *QGraphsView::axisY() const
++ {
++ return m_axisY;
++ }
++
++ void QGraphsView::setAxisY(QAbstractAxis *axis)
++ {
++ if (m_axisY == axis) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << axis;
++ return;
++ }
++ if (m_axisY)
++ removeAxis(m_axisY);
++ if (axis) {
++ if (axis->alignment() != Qt::AlignLeft && axis->alignment() != Qt::AlignRight)
++ axis->setAlignment(Qt::AlignLeft);
++ if (!addAxis(axis))
++ axis = nullptr;
++ }
++ m_axisY = axis;
++ updateComponentSizes();
++ emit axisYChanged();
++ update();
++ polishAndUpdate();
++ }
++
++ /*!
++ \property QGraphsView::orientation
++ \brief Orientation of the GraphsView.
++
++ Determines the orientation of the QGraphsView. When the orientation is
++ \l {Qt::Horizontal}{Qt::Horizontal}, \l axisX and \l axisY will switch the
++ positions so that \l axisX is rendered vertically and \l axisY horizontally.
++ This property is currently used by the \l QBarSeries.
++ The default value is \l {Qt::Vertical}{Qt::Vertical}.
++ */
++ /*!
++ \qmlproperty Qt.Orientation GraphsView::orientation
++ Determines the orientation of the GraphsView. When the orientation is
++ \l {Qt::Horizontal}{Qt.Horizontal}, \l axisX and \l axisY will switch the
++ positions so that \l axisX is rendered vertically and \l axisY horizontally.
++ This property is currently used by the \l BarSeries.
++ The default value is \l {Qt::Vertical}{Qt.Vertical}.
++ */
++ Qt::Orientation QGraphsView::orientation() const
++ {
++ return m_orientation;
++ }
++
++ void QGraphsView::setOrientation(Qt::Orientation newOrientation)
++ {
++ if (m_orientation == newOrientation) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newOrientation;
++ return;
++ }
++ m_orientation = newOrientation;
++ emit orientationChanged();
++ update();
++ updateComponentSizes();
++ polishAndUpdate();
++ }
++
++ #if QT_CONFIG(graphs_2d_custom)
++ /*
++ mapX and mapY functions are used to map custom series data values
++ to the real pixel values of the GraphsView
++ */
++ qreal QGraphsView::mapX(QCustomSeries *series, qreal x)
++ {
++ return m_customRenderer->mapX(m_axisRenderer, series, x);
++ }
++
++ qreal QGraphsView::mapY(QCustomSeries *series, qreal y)
++ {
++ return m_customRenderer->mapY(m_axisRenderer, series, y);
++ }
++ #endif
++
++ CustomRenderer *QGraphsView::customRenderer() const
++ {
++ return m_customRenderer;
++ }
++
++ /*!
++ \enum QGraphsView::ZoomStyle
++ This enum value describes the zoom style of the graph:
++
++ \value None
++ Zooming is disabled.
++ \value Center
++ Pinch zoom and mouse wheel zoom towards the center of the graph view.
++ */
++
++ /*!
++ \property QGraphsView::zoomStyle
++ \since 6.9
++ \brief Zoom style of the GraphsView.
++
++ Determines the zoom style of the QGraphsView. Zooming works by
++ manipulating the QValueAxis zoom property. The default value
++ is \c {QGraphsView::ZoomStyle::None}.
++ */
++ /*!
++ \qmlproperty enumeration GraphsView::zoomStyle
++ \since 6.9
++ Determines the zoom style of the GraphsView. Zooming works by
++ manipulating the ValueAxis zoom property. The default value
++ is \c {GraphsView.ZoomStyle.None}.
++
++ \value GraphsView.ZoomStyle.None
++ Zooming is disabled.
++ \value GraphsView.ZoomStyle.Center
++ Pinch zoom and mouse wheel zoom towards the center of the graph view.
++
++ */
++ QGraphsView::ZoomStyle QGraphsView::zoomStyle() const
++ {
++ return m_zoomStyle;
++ }
++
++ void QGraphsView::setZoomStyle(ZoomStyle newZoomStyle)
++ {
++ if (m_zoomStyle == newZoomStyle) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newZoomStyle;
++ return;
++ }
++ m_zoomStyle = newZoomStyle;
++ emit zoomStyleChanged();
++ }
++
++ /*!
++ \enum QGraphsView::PanStyle
++ This enum value describes the pan style of the graph:
++
++ \value None
++ Panning is disabled.
++ \value Drag
++ Mouse and touch drag pan the view around.
++ */
++
++ /*!
++ \property QGraphsView::panStyle
++ \since 6.9
++ \brief Pan style of the GraphsView.
++
++ Determines the pan style of the QGraphsView. Panning works by
++ manipulating the pan property of a QValueAxis.
++ The default value is \c {QGraphsView::PanStyle::None}.
++ */
++ /*!
++ \qmlproperty enumeration GraphsView::panStyle
++ \since 6.9
++ Determines the pan style of the GraphsView. Panning works by
++ manipulating the pan property of a ValueAxis.
++ The default value is \c {GraphsView.PanStyle.None}.
++
++ \value GraphsView.PanStyle.None
++ Panning is disabled.
++ \value GraphsView.PanStyle.Drag
++ Mouse and touch drag pan the view around.
++ */
++ QGraphsView::PanStyle QGraphsView::panStyle() const
++ {
++ return m_panStyle;
++ }
++
++ void QGraphsView::setPanStyle(PanStyle newPanStyle)
++ {
++ if (m_panStyle == newPanStyle) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newPanStyle;
++ return;
++ }
++ m_panStyle = newPanStyle;
++ emit panStyleChanged();
++ }
++
++ /*!
++ \property QGraphsView::zoomAreaEnabled
++ \since 6.9
++ \brief Enables zoom area
++
++ Zoom area changes mouse and touch dragging to draw a box determined
++ by \c zoomAreaDelegate. Upon release the graph QValueAxis zoom and pan
++ properties are changed so that the view covers only the area intersected
++ by the drawn box.
++ \sa zoomAreaDelegate
++ */
++ /*!
++ \qmlproperty bool GraphsView::zoomAreaEnabled
++ \since 6.9
++ Zoom area changes mouse and touch dragging to draw a box determined
++ by \c zoomAreaDelegate. Upon release the graph ValueAxis zoom and pan
++ properties are changed so that the view covers only the area intersected
++ by the drawn box.
++ \sa zoomAreaDelegate
++ */
++ bool QGraphsView::zoomAreaEnabled() const
++ {
++ return m_zoomAreaEnabled;
++ }
++
++ void QGraphsView::setZoomAreaEnabled(bool newZoomAreaEnabled)
++ {
++ if (m_zoomAreaEnabled == newZoomAreaEnabled) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newZoomAreaEnabled;
++ return;
++ }
++ m_zoomAreaEnabled = newZoomAreaEnabled;
++ emit zoomAreaEnabledChanged();
++ }
++
++ /*!
++ \property QGraphsView::zoomAreaDelegate
++ \since 6.9
++ \brief Zoom area visual delegate
++
++ Determines the QML element that is drawn when the user performs a drag
++ motion to zoom in to an area.
++ */
++ /*!
++ \qmlproperty Component GraphsView::zoomAreaDelegate
++ \since 6.9
++ Determines the QML element that is drawn when the user performs a drag
++ motion to zoom in to an area.
++ */
++ QQmlComponent *QGraphsView::zoomAreaDelegate() const
++ {
++ return m_zoomAreaDelegate;
++ }
++
++ void QGraphsView::setZoomAreaDelegate(QQmlComponent *newZoomAreaDelegate)
++ {
++ if (m_zoomAreaDelegate == newZoomAreaDelegate) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newZoomAreaDelegate;
++ return;
++ }
++ m_zoomAreaDelegate = newZoomAreaDelegate;
++
++ if (m_zoomAreaDelegate) {
++ m_zoomAreaItem = qobject_cast<QQuickItem *>(
++ m_zoomAreaDelegate->create(m_zoomAreaDelegate->creationContext()));
++ m_zoomAreaItem->setParent(this);
++ m_zoomAreaItem->setParentItem(this);
++ m_zoomAreaItem->setVisible(false);
++ }
++
++ emit zoomAreaDelegateChanged();
++ }
++
++ /*!
++ \property QGraphsView::zoomSensitivity
++ \since 6.9
++ \brief Zoom value change sensitivity
++
++ Determines how fast zoom value changes while zooming.
++ */
++ /*!
++ \qmlproperty real GraphsView::zoomSensitivity
++ \since 6.9
++ Determines how fast zoom value changes while zooming.
++ */
++ qreal QGraphsView::zoomSensitivity() const
++ {
++ return m_zoomSensitivity;
++ }
++
++ void QGraphsView::setZoomSensitivity(qreal newZoomSensitivity)
++ {
++ if (QtPrivate::fuzzyCompare(m_zoomSensitivity, newZoomSensitivity)) {
++ qCDebug(lcViewProperties2D, "%s value is already set to: %.1f",
++ qUtf8Printable(QLatin1String(__FUNCTION__)), newZoomSensitivity);
++ return;
++ }
++ m_zoomSensitivity = newZoomSensitivity;
++ emit zoomSensitivityChanged();
++ }
++
++ /*!
++ \property QGraphsView::dynamicLabelMargins
++ \brief Calculate label margins dynamically based on content
++
++ This property holds whether label margins adjust dynamically.
++
++ By default, labels wider than the allocated margin overlap other
++ graph elements. When enabled, the renderer reserves extra space
++ for such labels and repositions axes to prevent overlap.
++ */
++ /*!
++ \qmlproperty bool GraphsView::dynamicLabelMargins
++ This property holds whether label margins adjust dynamically.
++
++ By default, labels wider than the allocated margin overlap other
++ graph elements. When enabled, the renderer reserves extra space
++ for such labels and repositions axes to prevent overlap.
++ */
++ bool QGraphsView::dynamicLabelMargins() const
++ {
++ return m_dynamicLabelMargins;
++ }
++
++ void QGraphsView::setDynamicLabelMargins(bool newDynamicLabelMargins)
++ {
++ if (m_dynamicLabelMargins == newDynamicLabelMargins) {
++ qCDebug(lcViewProperties2D) << __FUNCTION__
++ << "value is already set to:" << newDynamicLabelMargins;
++ return;
++ }
++ m_dynamicLabelMargins = newDynamicLabelMargins;
++ updateComponentSizes();
++ emit dynamicLabelMarginsChanged();
++ polishAndUpdate();
++ }
++
++ int QGraphsView::getSeriesRendererIndex(QAbstractSeries *series)
++ {
++ int index = 0;
++ if (series) {
++ switch (QAbstractSeriesPrivate::get(series)->type()) {
++ case QAbstractSeries::SeriesType::Bar:
++ index = 0;
++ break;
++ case QAbstractSeries::SeriesType::Scatter:
++ case QAbstractSeries::SeriesType::Line:
++ case QAbstractSeries::SeriesType::Spline:
++ index = 1;
++ break;
++ case QAbstractSeries::SeriesType::Area:
++ index = 2;
++ break;
++ case QAbstractSeries::SeriesType::Pie:
++ index = 3;
++ break;
++ case QAbstractSeries::SeriesType::Custom:
++ index = 4;
++ break;
++ }
++ }
++ return index;
++ }
++
++ /*!
++ \qmlproperty bool GraphsView::useCanvasPainter
++ \since 6.12
++ This property holds whether the graph draws with \l {Qt Canvas Painter}
++ instead of \l {Qt Quick Shapes}. The default is \c false, except in a
++ build where the high-performance backend is the only one available.
++
++ In a build without the high-performance backend, this property stays
++ \c false and setting it has no effect.
++
++ For a comparison of the two renderers and for how to build them, see
++ \l {Qt Graphs 2D Rendering Backends}.
++ */
++ bool QGraphsView::useCanvasPainter() const
++ {
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ return m_useCanvasPainter;
++ #else
++ return false;
++ #endif
++ }
++
++ void QGraphsView::setUseCanvasPainter(bool newUseCanvasPainter)
++ {
++ #if QT_CONFIG(graphs_2d_high_performance_backend)
++ if (m_useCanvasPainter == newUseCanvasPainter)
++ return;
++ m_useCanvasPainter = newUseCanvasPainter;
++
++ if (m_useCanvasPainter)
++ createCanvasPainter();
++ else
++ removeCanvasPainter();
++
++ emit useCanvasPainterChanged();
++ // The renderers only refresh their backend-specific geometry during a polish, so without
++ // this the outgoing backend's last-drawn output would linger until something else happened
++ // to trigger one.
++ update();
++ polishAndUpdate();
++ #else
++ Q_UNUSED(newUseCanvasPainter);
++ #endif
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qgraphsview_p.cpp"