Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <private/xychart_p.h>
++ #include <QtCharts/QXYSeries>
++ #include <private/qxyseries_p.h>
++ #include <private/chartpresenter_p.h>
++ #include <private/abstractdomain_p.h>
++ #include <private/chartdataset_p.h>
++ #include <private/glxyseriesdata_p.h>
++ #include <QtCharts/QXYModelMapper>
++ #include <private/qabstractaxis_p.h>
++ #include <QtGui/QPainter>
++ #include <QtCore/QAbstractItemModel>
++
++
++ QT_BEGIN_NAMESPACE
++
++ XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
++ ChartItem(series->d_func(),item),
++ m_series(series),
++ m_animation(0),
++ m_dirty(true)
++ {
++ connect(series->d_func(), &QXYSeriesPrivate::seriesUpdated,
++ this, &XYChart::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointReplaced, this, &XYChart::handlePointReplaced);
++ connect(series, &QXYSeries::pointsReplaced, this, &XYChart::handlePointsReplaced);
++ connect(series, &QXYSeries::pointAdded, this, &XYChart::handlePointAdded);
++ connect(series, &QXYSeries::pointRemoved, this, &XYChart::handlePointRemoved);
++ connect(series, &QXYSeries::pointsRemoved, this, &XYChart::handlePointsRemoved);
++ connect(this, &XYChart::clicked, series, &QXYSeries::clicked);
++ connect(this, &XYChart::hovered, series, &QXYSeries::hovered);
++ connect(this, &XYChart::pressed, series, &QXYSeries::pressed);
++ connect(this, &XYChart::released, series, &QXYSeries::released);
++ connect(this, &XYChart::doubleClicked, series, &QXYSeries::doubleClicked);
++ connect(series, &QAbstractSeries::useOpenGLChanged, this, &XYChart::handleDomainUpdated);
++ }
++
++ void XYChart::setGeometryPoints(const QList<QPointF> &points)
++ {
++ m_points = points;
++ }
++
++ void XYChart::setAnimation(XYAnimation *animation)
++ {
++ m_animation = animation;
++ }
++
++ void XYChart::setDirty(bool dirty)
++ {
++ m_dirty = dirty;
++ }
++
++ // Returns a list with same size as geometryPoints list, indicating
++ // the off grid status of points.
++ QList<bool> XYChart::offGridStatusVector()
++ {
++ qreal minX = domain()->minX();
++ qreal maxX = domain()->maxX();
++ qreal minY = domain()->minY();
++ qreal maxY = domain()->maxY();
++
++ QList<bool> returnVector;
++ returnVector.resize(m_points.size());
++ // During remove animation series may have different number of points,
++ // so ensure we don't go over the index. No need to check for zero points, this
++ // will not be called in such a situation.
++ const int seriesLastIndex = m_series->count() - 1;
++
++ for (int i = 0; i < m_points.size(); i++) {
++ const QPointF &seriesPoint = m_series->at(qMin(seriesLastIndex, i));
++ if (seriesPoint.x() < minX
++ || seriesPoint.x() > maxX
++ || seriesPoint.y() < minY
++ || seriesPoint.y() > maxY) {
++ returnVector[i] = true;
++ } else {
++ returnVector[i] = false;
++ }
++ }
++ return returnVector;
++ }
++
++ void XYChart::updateChart(const QList<QPointF> &oldPoints, const QList<QPointF> &newPoints,
++ int index)
++ {
++
++ if (m_animation) {
++ m_animation->setup(oldPoints, newPoints, index);
++ m_points = newPoints;
++ setDirty(false);
++ presenter()->startAnimation(m_animation);
++ } else {
++ m_points = newPoints;
++ updateGeometry();
++ }
++ }
++
++ void XYChart::updateGlChart()
++ {
++ dataSet()->glXYSeriesDataManager()->setPoints(m_series, domain());
++ presenter()->updateGLWidget();
++ updateGeometry();
++ }
++
++ // Doesn't update gl geometry, but refreshes the chart
++ void XYChart::refreshGlChart()
++ {
++ if (presenter())
++ presenter()->updateGLWidget();
++ }
++
++ //handlers
++
++ void XYChart::handlePointAdded(int index)
++ {
++ Q_ASSERT(index < m_series->count());
++ Q_ASSERT(index >= 0);
++
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ QList<QPointF> points;
++ if (m_dirty || m_points.isEmpty()) {
++ points = domain()->calculateGeometryPoints(m_series->points());
++ } else {
++ points = m_points;
++ QPointF point =
++ domain()->calculateGeometryPoint(m_series->points().at(index), m_validData);
++ if (!m_validData)
++ m_points.clear();
++ else
++ points.insert(index, point);
++ }
++ updateChart(m_points, points, index);
++ }
++ }
++
++ void XYChart::handlePointRemoved(int index)
++ {
++ Q_ASSERT(index <= m_series->count());
++ Q_ASSERT(index >= 0);
++
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ QList<QPointF> points;
++ if (m_dirty || m_points.isEmpty()) {
++ points = domain()->calculateGeometryPoints(m_series->points());
++ } else {
++ points = m_points;
++ points.remove(index);
++ }
++ updateChart(m_points, points, index);
++ }
++ }
++
++ void XYChart::handlePointsRemoved(int index, int count)
++ {
++ Q_ASSERT(index <= m_series->count());
++ Q_ASSERT(index >= 0);
++
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ QList<QPointF> points;
++ if (m_dirty || m_points.isEmpty()) {
++ points = domain()->calculateGeometryPoints(m_series->points());
++ } else {
++ points = m_points;
++ points.remove(index, count);
++ }
++ updateChart(m_points, points, index);
++ }
++ }
++
++ void XYChart::handlePointReplaced(int index)
++ {
++ Q_ASSERT(index < m_series->count());
++ Q_ASSERT(index >= 0);
++
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ QList<QPointF> points;
++ if (m_dirty || m_points.isEmpty()) {
++ points = domain()->calculateGeometryPoints(m_series->points());
++ } else {
++ QPointF point =
++ domain()->calculateGeometryPoint(m_series->points().at(index), m_validData);
++ if (!m_validData)
++ m_points.clear();
++ points = m_points;
++ if (m_validData)
++ points.replace(index, point);
++ }
++ updateChart(m_points, points, index);
++ }
++ }
++
++ void XYChart::handlePointsReplaced()
++ {
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ // All the points were replaced -> recalculate
++ QList<QPointF> points = domain()->calculateGeometryPoints(m_series->points());
++ updateChart(m_points, points, -1);
++ }
++ }
++
++ void XYChart::handleDomainUpdated()
++ {
++ if (m_series->useOpenGL()) {
++ updateGlChart();
++ } else {
++ if (isEmpty()) return;
++ QList<QPointF> points = domain()->calculateGeometryPoints(m_series->points());
++ updateChart(m_points, points);
++ }
++ }
++
++ void XYChart::handleSeriesUpdated()
++ {
++ }
++
++ bool XYChart::isEmpty()
++ {
++ return domain()->isEmpty() || m_series->points().isEmpty();
++ }
++
++ QPointF XYChart::matchForLightMarker(const QPointF &eventPos) const
++ {
++ if (m_series->lightMarker().isNull()
++ && (m_series->selectedLightMarker().isNull()
++ || m_series->selectedPoints().isEmpty()))
++ return QPointF(qQNaN(), qQNaN()); // 0,0 could actually be in points()
++
++ const bool useSelectedMarker = m_series->lightMarker().isNull();
++
++ QList<QPointF> points;
++ if (useSelectedMarker) {
++ const auto selectedPoints = m_series->selectedPoints();
++ for (const int &selectedPointIndex : selectedPoints)
++ points << m_series->at(selectedPointIndex);
++ } else {
++ points = m_series->points();
++ }
++
++ for (const QPointF &dp : std::as_const(points)) {
++ bool ok;
++ const QPointF gp = domain()->calculateGeometryPoint(dp, ok);
++ if (ok) {
++ // '+2' and '+4': There is an addRect for the (mouse-)shape
++ // in LineChartItem::updateGeometry()
++ // This has a margin of 1 to make sure a press in the icon will always be detected,
++ // but as there is a bunch of 'translations' and therefore inaccuracies,
++ // so it is necessary to increase that margin to 2
++ // (otherwise you can click next to an icon, get a click event but not match it)
++ QRectF r(gp.x() - (m_series->markerSize() / 2 + 2),
++ gp.y() - (m_series->markerSize() / 2 + 2),
++ m_series->markerSize() + 4, m_series->markerSize() + 4);
++
++ if (r.contains(eventPos))
++ return dp;
++ }
++ }
++ return QPointF(qQNaN(), qQNaN()); // 0,0 could actually be in points()
++ }
++
++ QPointF XYChart::hoverPoint(const QPointF &eventPos) const
++ {
++ const QPointF result = matchForLightMarker(eventPos);
++ return qIsNaN(result.x())
++ ? domain()->calculateDomainPoint(eventPos)
++ : result;
++ }
++
++ bool XYChart::fuzzyComparePointF(const QPointF &p1, const QPointF &p2)
++ {
++ // Should normally not be NaN, fail on safe side
++ return !qIsNaN(p1.x()) && !qIsNaN(p2.x())
++ && qFuzzyCompare(p1.x(), p2.x()) && qFuzzyCompare(p1.y(), p2.y());
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_xychart_p.cpp"