Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <private/linechartitem_p.h>
++ #include <QtCharts/QLineSeries>
++ #include <private/qlineseries_p.h>
++ #include <private/chartpresenter_p.h>
++ #include <private/polardomain_p.h>
++ #include <private/chartthememanager_p.h>
++ #include <private/charttheme_p.h>
++ #include <QtGui/QPainter>
++ #include <QtWidgets/QGraphicsSceneMouseEvent>
++
++ QT_BEGIN_NAMESPACE
++
++ LineChartItem::LineChartItem(QLineSeries *series, QGraphicsItem *item)
++ : XYChart(series,item),
++ m_series(series),
++ m_pointsVisible(false),
++ m_chartType(QChart::ChartTypeUndefined),
++ m_pointLabelsVisible(false),
++ m_markerSize(series->markerSize()),
++ m_pointLabelsFormat(series->pointLabelsFormat()),
++ m_pointLabelsFont(series->pointLabelsFont()),
++ m_pointLabelsColor(series->pointLabelsColor()),
++ m_pointLabelsClipping(true),
++ m_lastHoveredMatchedPos{qQNaN(), qQNaN()},
++ m_mousePressed(false)
++ {
++ setAcceptHoverEvents(true);
++ setFlag(QGraphicsItem::ItemIsSelectable);
++ setZValue(ChartPresenter::LineChartZValue);
++ connect(series->d_func(), &QXYSeriesPrivate::seriesUpdated,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::lightMarkerChanged, this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::selectedLightMarkerChanged, this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::markerSizeChanged, this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::visibleChanged, this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::opacityChanged, this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointLabelsFormatChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointLabelsVisibilityChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointLabelsFontChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointLabelsColorChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QXYSeries::pointLabelsClippingChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QLineSeries::selectedColorChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QLineSeries::selectedPointsChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++ connect(series, &QLineSeries::pointsConfigurationChanged,
++ this, &LineChartItem::handleSeriesUpdated);
++
++ handleSeriesUpdated();
++ }
++
++ QRectF LineChartItem::boundingRect() const
++ {
++ return m_rect;
++ }
++
++ QPainterPath LineChartItem::shape() const
++ {
++ return m_shapePath;
++ }
++
++ void LineChartItem::updateGeometry()
++ {
++ if (m_series->useOpenGL()) {
++ if (!m_rect.isEmpty()) {
++ prepareGeometryChange();
++ // Changed signal seems to trigger even with empty region
++ m_rect = QRectF();
++ }
++ update();
++ return;
++ }
++
++ // Store the points to a local variable so that the old line gets properly cleared
++ // when animation starts.
++ m_linePoints = geometryPoints();
++ const QList<QPointF> &points = m_linePoints;
++
++ if (points.size() == 0) {
++ prepareGeometryChange();
++ m_linePathPolarRight = QPainterPath();
++ m_linePathPolarLeft = QPainterPath();
++ m_fullPath = QPainterPath();
++ m_linePath = QPainterPath();
++ m_rect = QRect();
++ return;
++ }
++
++ QPainterPath linePath;
++ QPainterPath fullPath;
++ // Use worst case scenario to determine required margin.
++ qreal margin = m_linePen.width() * 1.42;
++
++ // Area series use component line series that aren't necessarily added to the chart themselves,
++ // so check if chart type is forced before trying to obtain it from the chart.
++ QChart::ChartType chartType = m_chartType;
++ if (chartType == QChart::ChartTypeUndefined)
++ chartType = m_series->chart()->chartType();
++
++ // For polar charts, we need special handling for angular (horizontal)
++ // points that are off-grid.
++ if (chartType == QChart::ChartTypePolar) {
++ QPainterPath linePathLeft;
++ QPainterPath linePathRight;
++ QPainterPath *currentSegmentPath = 0;
++ QPainterPath *previousSegmentPath = 0;
++ qreal minX = domain()->minX();
++ qreal maxX = domain()->maxX();
++ qreal minY = domain()->minY();
++ QPointF currentSeriesPoint = m_series->at(0);
++ QPointF currentGeometryPoint = points.at(0);
++ QPointF previousGeometryPoint = points.at(0);
++ bool pointOffGrid = false;
++ bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
++
++ qreal domainRadius = domain()->size().height() / 2.0;
++ const QPointF centerPoint(domainRadius, domainRadius);
++
++ if (!previousPointWasOffGrid) {
++ fullPath.moveTo(points.at(0));
++ if (m_pointsVisible && currentSeriesPoint.y() >= minY) {
++ // Do not draw ellipses for points below minimum Y.
++ linePath.addEllipse(points.at(0), m_markerSize, m_markerSize);
++ fullPath.addEllipse(points.at(0), m_markerSize, m_markerSize);
++ linePath.moveTo(points.at(0));
++ fullPath.moveTo(points.at(0));
++ }
++ }
++
++ qreal leftMarginLine = centerPoint.x() - margin;
++ qreal rightMarginLine = centerPoint.x() + margin;
++ qreal horizontal = centerPoint.y();
++
++ // See ScatterChartItem::updateGeometry() for explanation why seriesLastIndex is needed
++ const int seriesLastIndex = m_series->count() - 1;
++
++ for (int i = 1; i < points.size(); i++) {
++ // Interpolating line fragments would be ugly when thick pen is used,
++ // so we work around it by utilizing three separate
++ // paths for line segments and clip those with custom regions at paint time.
++ // "Right" path contains segments that cross the axis line with visible point on the
++ // right side of the axis line, as well as segments that have one point within the margin
++ // on the right side of the axis line and another point on the right side of the chart.
++ // "Left" path contains points with similarly on the left side.
++ // "Full" path contains rest of the points.
++ // This doesn't yield perfect results always. E.g. when segment covers more than 90
++ // degrees and both of the points are within the margin, one in the top half and one in the
++ // bottom half of the chart, the bottom one gets clipped incorrectly.
++ // However, this should be rare occurrence in any sensible chart.
++ currentSeriesPoint = m_series->at(qMin(seriesLastIndex, i));
++ currentGeometryPoint = points.at(i);
++ pointOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
++
++ // Draw something unless both off-grid
++ if (!pointOffGrid || !previousPointWasOffGrid) {
++ QPointF intersectionPoint;
++ qreal y;
++ if (pointOffGrid != previousPointWasOffGrid) {
++ if (currentGeometryPoint.x() == previousGeometryPoint.x()) {
++ y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) / 2.0;
++ } else {
++ qreal ratio = (centerPoint.x() - currentGeometryPoint.x()) / (currentGeometryPoint.x() - previousGeometryPoint.x());
++ y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) * ratio;
++ }
++ intersectionPoint = QPointF(centerPoint.x(), y);
++ }
++
++ bool dummyOk; // We know points are ok, but this is needed
++ qreal currentAngle = 0;
++ qreal previousAngle = 0;
++ if (const PolarDomain *pd = qobject_cast<const PolarDomain *>(domain())) {
++ currentAngle = pd->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
++ previousAngle = pd->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
++ } else {
++ qWarning() << Q_FUNC_INFO << "Unexpected domain: " << domain();
++ }
++ if ((qAbs(currentAngle - previousAngle) > 180.0)) {
++ // If the angle between two points is over 180 degrees (half X range),
++ // any direct segment between them becomes meaningless.
++ // In this case two line segments are drawn instead, from previous
++ // point to the center and from center to current point.
++ if ((previousAngle < 0.0 || (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
++ && previousGeometryPoint.y() < horizontal) {
++ currentSegmentPath = &linePathRight;
++ } else if ((previousAngle > 360.0 || (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
++ && previousGeometryPoint.y() < horizontal) {
++ currentSegmentPath = &linePathLeft;
++ } else if (previousAngle > 0.0 && previousAngle < 360.0) {
++ currentSegmentPath = &linePath;
++ } else {
++ currentSegmentPath = 0;
++ }
++
++ if (currentSegmentPath) {
++ if (previousSegmentPath != currentSegmentPath)
++ currentSegmentPath->moveTo(previousGeometryPoint);
++ if (previousPointWasOffGrid)
++ fullPath.moveTo(intersectionPoint);
++
++ currentSegmentPath->lineTo(centerPoint);
++ fullPath.lineTo(centerPoint);
++ }
++
++ previousSegmentPath = currentSegmentPath;
++
++ if ((currentAngle < 0.0 || (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
++ && currentGeometryPoint.y() < horizontal) {
++ currentSegmentPath = &linePathRight;
++ } else if ((currentAngle > 360.0 || (currentAngle > 180.0 &¤tGeometryPoint.x() > leftMarginLine))
++ && currentGeometryPoint.y() < horizontal) {
++ currentSegmentPath = &linePathLeft;
++ } else if (currentAngle > 0.0 && currentAngle < 360.0) {
++ currentSegmentPath = &linePath;
++ } else {
++ currentSegmentPath = 0;
++ }
++
++ if (currentSegmentPath) {
++ if (previousSegmentPath != currentSegmentPath)
++ currentSegmentPath->moveTo(centerPoint);
++ if (!previousSegmentPath)
++ fullPath.moveTo(centerPoint);
++
++ currentSegmentPath->lineTo(currentGeometryPoint);
++ if (pointOffGrid)
++ fullPath.lineTo(intersectionPoint);
++ else
++ fullPath.lineTo(currentGeometryPoint);
++ }
++ } else {
++ if (previousAngle < 0.0 || currentAngle < 0.0
++ || ((previousAngle <= 180.0 && currentAngle <= 180.0)
++ && ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
++ || (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
++ currentSegmentPath = &linePathRight;
++ } else if (previousAngle > 360.0 || currentAngle > 360.0
++ || ((previousAngle > 180.0 && currentAngle > 180.0)
++ && ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
++ || (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
++ currentSegmentPath = &linePathLeft;
++ } else {
++ currentSegmentPath = &linePath;
++ }
++
++ if (currentSegmentPath != previousSegmentPath)
++ currentSegmentPath->moveTo(previousGeometryPoint);
++ if (previousPointWasOffGrid)
++ fullPath.moveTo(intersectionPoint);
++
++ if (pointOffGrid)
++ fullPath.lineTo(intersectionPoint);
++ else
++ fullPath.lineTo(currentGeometryPoint);
++ currentSegmentPath->lineTo(currentGeometryPoint);
++ }
++ } else {
++ currentSegmentPath = 0;
++ }
++
++ previousPointWasOffGrid = pointOffGrid;
++ if (m_pointsVisible && !pointOffGrid && currentSeriesPoint.y() >= minY) {
++ linePath.addEllipse(points.at(i), m_markerSize, m_markerSize);
++ fullPath.addEllipse(points.at(i), m_markerSize, m_markerSize);
++ linePath.moveTo(points.at(i));
++ fullPath.moveTo(points.at(i));
++ }
++ previousSegmentPath = currentSegmentPath;
++ previousGeometryPoint = currentGeometryPoint;
++ }
++ m_linePathPolarRight = linePathRight;
++ m_linePathPolarLeft = linePathLeft;
++ // Note: This construction of m_fullpath is not perfect. The partial segments that are
++ // outside left/right clip regions at axis boundary still generate hover/click events,
++ // because shape doesn't get clipped. It doesn't seem possible to do sensibly.
++ } else { // not polar
++ linePath.moveTo(points.at(0));
++ for (int i = 1; i < points.size(); i++)
++ linePath.lineTo(points.at(i));
++ fullPath = linePath;
++ }
++
++ QPainterPathStroker stroker;
++ // QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
++ // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
++ // multiply line width with square root of two when defining shape and bounding rectangle.
++ stroker.setWidth(margin);
++ stroker.setJoinStyle(Qt::MiterJoin);
++ stroker.setCapStyle(Qt::SquareCap);
++ stroker.setMiterLimit(m_linePen.miterLimit());
++
++ QPainterPath checkShapePath = stroker.createStroke(fullPath);
++
++ // For mouse interactivity, we have to add the rects *after* the 'createStroke',
++ // as we don't need the outline - we need it filled up.
++ if (!m_series->lightMarker().isNull()
++ || (!m_series->selectedLightMarker().isNull()
++ && !m_series->selectedPoints().isEmpty())) {
++ // +1, +2: a margin to guarantee we cover all of the pixmap
++ qreal markerHalfSize = (m_markerSize / 2.0) + 1;
++ qreal markerSize = m_markerSize + 2;
++
++ for (const auto &point : std::as_const(m_linePoints)) {
++ checkShapePath.addRect(point.x() - markerHalfSize,
++ point.y() - markerHalfSize,
++ markerSize, markerSize);
++ }
++ }
++
++ // Only zoom in if the bounding rects of the paths fit inside int limits. QWidget::update() uses
++ // a region that has to be compatible with QRect.
++ if (checkShapePath.boundingRect().height() <= INT_MAX
++ && checkShapePath.boundingRect().width() <= INT_MAX
++ && linePath.boundingRect().height() <= INT_MAX
++ && linePath.boundingRect().width() <= INT_MAX
++ && fullPath.boundingRect().height() <= INT_MAX
++ && fullPath.boundingRect().width() <= INT_MAX) {
++ prepareGeometryChange();
++
++ m_linePath = linePath;
++ m_fullPath = fullPath;
++ m_shapePath = checkShapePath;
++
++ m_rect = m_shapePath.boundingRect();
++ } else {
++ update();
++ }
++ }
++
++ void LineChartItem::handleSeriesUpdated()
++ {
++ bool doGeometryUpdate =
++ (m_pointsVisible != m_series->pointsVisible())
++ || (m_series->pointsVisible()
++ && (m_linePen != m_series->pen()
++ || m_selectedColor != m_series->selectedColor()
++ || m_selectedPoints != m_series->selectedPoints()))
++ || m_series->pointsConfiguration() != m_pointsConfiguration
++ || (m_markerSize != m_series->markerSize());
++ bool visibleChanged = m_series->isVisible() != isVisible();
++ setVisible(m_series->isVisible());
++ setOpacity(m_series->opacity());
++ m_pointsVisible = m_series->pointsVisible();
++
++ qreal seriesPenWidth = m_series->pen().widthF();
++ if (m_series->d_func()->isMarkerSizeDefault()
++ && (!qFuzzyCompare(seriesPenWidth, m_linePen.widthF()))) {
++ m_series->d_func()->setMarkerSize(seriesPenWidth * 1.5);
++ }
++ m_linePen = m_series->pen();
++ m_markerSize = m_series->markerSize();
++ m_pointLabelsFormat = m_series->pointLabelsFormat();
++ m_pointLabelsVisible = m_series->pointLabelsVisible();
++ m_pointLabelsFont = m_series->pointLabelsFont();
++ m_pointLabelsColor = m_series->pointLabelsColor();
++ m_selectedColor = m_series->selectedColor();
++ m_selectedPoints = m_series->selectedPoints();
++ m_pointsConfiguration = m_series->pointsConfiguration();
++ bool labelClippingChanged = m_pointLabelsClipping != m_series->pointLabelsClipping();
++ m_pointLabelsClipping = m_series->pointLabelsClipping();
++ if (doGeometryUpdate)
++ updateGeometry();
++ else if (m_series->useOpenGL() && visibleChanged)
++ refreshGlChart();
++
++ // Update whole chart in case label clipping changed as labels can be outside series area
++ if (labelClippingChanged)
++ m_series->chart()->update();
++ else
++ update();
++ }
++
++ void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
++ {
++ Q_UNUSED(widget);
++ Q_UNUSED(option);
++
++ if (m_series->useOpenGL())
++ return;
++
++ QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
++ // Adjust clip rect half a pixel in required dimensions to make it include lines along the
++ // plot area edges, but never increase clip so much that any portion of the line is draw beyond
++ // the plot area.
++ const qreal x1 = pos().x() - int(pos().x());
++ const qreal y1 = pos().y() - int(pos().y());
++ const qreal x2 = (clipRect.width() + 0.5) - int(clipRect.width() + 0.5);
++ const qreal y2 = (clipRect.height() + 0.5) - int(clipRect.height() + 0.5);
++ clipRect.adjust(-x1, -y1, qMax(x1, x2), qMax(y1, y2));
++
++ painter->save();
++ painter->setPen(m_linePen);
++ bool alwaysUsePath = false;
++
++ if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
++ qreal halfWidth = domain()->size().width() / 2.0;
++ QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
++ QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
++ QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
++ QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
++ QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
++ painter->setClipRegion(clipRegionLeft);
++ painter->drawPath(m_linePathPolarLeft);
++ painter->setClipRegion(clipRegionRight);
++ painter->drawPath(m_linePathPolarRight);
++ painter->setClipRegion(fullPolarClipRegion);
++ alwaysUsePath = true; // required for proper clipping
++ } else {
++ painter->setClipRect(clipRect);
++ }
++
++ if (m_series->bestFitLineVisible())
++ m_series->d_func()->drawBestFitLine(painter, clipRect);
++
++ if (m_linePen.style() != Qt::SolidLine || alwaysUsePath) {
++ // If pen style is not solid line, use path painting to ensure proper pattern continuity
++ painter->drawPath(m_linePath);
++ } else {
++ for (int i = 1; i < m_linePoints.size(); ++i)
++ painter->drawLine(m_linePoints.at(i - 1), m_linePoints.at(i));
++ }
++
++ int pointLabelsOffset = m_linePen.width() / 2;
++
++ // Draw markers if a marker or marker for selected points only has been
++ // set (set to QImage() to disable)
++ if (!m_series->lightMarker().isNull() || (!m_series->selectedLightMarker().isNull()
++ && !m_series->selectedPoints().isEmpty())) {
++ const QImage &marker = m_series->lightMarker();
++ const QImage &selectedMarker = m_series->selectedLightMarker();
++ qreal markerHalfSize = m_markerSize / 2.0;
++ pointLabelsOffset = markerHalfSize;
++
++ for (int i = 0; i < m_linePoints.size(); ++i) {
++ // Documentation of light markers says that points visibility and
++ // light markers are independent features. Therefore m_pointsVisible
++ // is not used here as light markers are drawn if lightMarker is not null.
++ // However points visibility configuration can be still used here.
++ bool drawPoint = !m_series->lightMarker().isNull();
++ if (m_pointsConfiguration.contains(i)) {
++ const auto &conf = m_pointsConfiguration[i];
++
++ if (conf.contains(QXYSeries::PointConfiguration::Visibility)) {
++ drawPoint = m_pointsConfiguration[i][QXYSeries::PointConfiguration::Visibility]
++ .toBool();
++ }
++ }
++
++ bool drawSelectedPoint = false;
++ if (m_series->isPointSelected(i)) {
++ drawPoint = true;
++ drawSelectedPoint = !selectedMarker.isNull();
++ }
++ if (drawPoint) {
++ const QRectF rect(m_linePoints[i].x() - markerHalfSize,
++ m_linePoints[i].y() - markerHalfSize,
++ m_markerSize, m_markerSize);
++ painter->drawImage(rect, drawSelectedPoint ? selectedMarker : marker);
++ }
++ }
++ }
++
++ m_series->d_func()->drawPointLabels(painter, m_linePoints, pointLabelsOffset);
++
++ const bool simpleDraw = m_selectedPoints.isEmpty() && m_pointsConfiguration.isEmpty();
++
++ painter->setPen(Qt::NoPen);
++ painter->setBrush(m_linePen.color());
++ painter->setClipping(true);
++ if (m_pointsVisible && simpleDraw && m_series->lightMarker().isNull()) {
++ for (int i = 0; i < m_linePoints.size(); ++i)
++ painter->drawEllipse(m_linePoints.at(i), m_markerSize, m_markerSize);
++ } else if (!simpleDraw) {
++ qreal ptSize = m_markerSize;
++ for (int i = 0; i < m_linePoints.size(); ++i) {
++ if (clipRect.contains(m_linePoints.at(i))) {
++ painter->save();
++ ptSize = m_markerSize;
++ bool drawPoint = m_pointsVisible && m_series->lightMarker().isNull();
++ if (m_pointsConfiguration.contains(i)) {
++ const auto &conf = m_pointsConfiguration[i];
++ if (conf.contains(QXYSeries::PointConfiguration::Visibility)) {
++ drawPoint =
++ m_pointsConfiguration[i][QXYSeries::PointConfiguration::Visibility]
++ .toBool();
++ }
++
++ if (drawPoint) {
++ if (conf.contains(QXYSeries::PointConfiguration::Size)) {
++ ptSize = m_pointsConfiguration[i][QXYSeries::PointConfiguration::Size]
++ .toReal();
++ }
++
++ if (conf.contains(QXYSeries::PointConfiguration::Color)) {
++ painter->setBrush(
++ m_pointsConfiguration[i][QXYSeries::PointConfiguration::Color]
++ .value<QColor>());
++ }
++ }
++ }
++
++ if (m_series->isPointSelected(i)) {
++ // Selected points are drawn regardless of m_pointsVisible settings and
++ // custom point configuration. However, they are not drawn if light markers
++ // are used. The reason of this is to avoid displaying selected point
++ // over selected light marker.
++ drawPoint = m_series->selectedLightMarker().isNull();
++ ptSize = ptSize * 1.5;
++ if (m_selectedColor.isValid())
++ painter->setBrush(m_selectedColor);
++ }
++
++ if (drawPoint)
++ painter->drawEllipse(m_linePoints.at(i), ptSize, ptSize);
++
++ painter->restore();
++ }
++ }
++ }
++ painter->restore();
++ }
++
++ void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
++ {
++ QPointF matchedP = matchForLightMarker(event->pos());
++ if (!qIsNaN(matchedP.x()))
++ emit XYChart::pressed(matchedP);
++ else
++ emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
++
++ m_lastMousePos = event->pos();
++ m_mousePressed = true;
++ QGraphicsItem::mousePressEvent(event);
++ }
++
++ void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
++ {
++ // Identical code in SplineChartItem
++ const QPointF matchedP = hoverPoint(event->pos());
++ m_lastHoveredMatchedPos = matchedP;
++ emit XYChart::hovered(matchedP, true);
++
++ // event->accept();
++ QGraphicsItem::hoverEnterEvent(event);
++ }
++
++ void LineChartItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
++ {
++ const QPointF matchedP = hoverPoint(event->pos());
++ if (!fuzzyComparePointF(matchedP, m_lastHoveredMatchedPos)) {
++ emit XYChart::hovered(matchedP, true);
++ m_lastHoveredMatchedPos = matchedP;
++ }
++
++ QGraphicsItem::hoverMoveEvent(event);
++ }
++
++ void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
++ {
++ const QPointF matchedP = hoverPoint(event->pos());
++ emit XYChart::hovered(matchedP, false);
++ m_lastHoveredMatchedPos = {qQNaN(), qQNaN()};
++
++ // event->accept();
++ QGraphicsItem::hoverEnterEvent(event);
++ }
++
++ void LineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
++ {
++ QPointF result;
++ QPointF matchedP = matchForLightMarker(m_lastMousePos);
++ if (!qIsNaN(matchedP.x()))
++ result = matchedP;
++ else
++ result = domain()->calculateDomainPoint(m_lastMousePos);
++
++ emit XYChart::released(result);
++ if (m_mousePressed)
++ emit XYChart::clicked(result);
++ m_mousePressed = false;
++ QGraphicsItem::mouseReleaseEvent(event);
++ }
++
++ void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
++ {
++ QPointF matchedP = matchForLightMarker(event->pos());
++ if (!qIsNaN(matchedP.x()))
++ emit XYChart::doubleClicked(matchedP);
++ else
++ emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
++
++ QGraphicsItem::mouseDoubleClickEvent(event);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_linechartitem_p.cpp"