HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2830:1757b2dc576a

Use empty rect for gl series instead of small dummy rect...

Miikka Heikkinen -

r2830:1757b2dc576a

parent child

Context file:

r2830:1757b2dc576a

Collapse all files

src/charts/linechart/linechartitem.cpp +3 -4

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #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_CHARTS_BEGIN_NAMESPACE
             const qreal mouseEventMinWidth(12);
             LineChartItem::LineChartItem(QLineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_chartType(QChart::ChartTypeUndefined),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_pointLabelsClipping(true),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsClippingChanged(bool)), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_shapePath;
             }
             void LineChartItem::updateGeometry()
             {
-                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
                 if (m_series->useOpenGL()) {
-                    // Fake a miniscule region, so we trigger changed signal.
+                    if (!m_rect.isEmpty()) {
-                    if (m_rect.width() != dummyRect.width()) {
                         prepareGeometryChange();
-                        m_rect = dummyRect;
+                        // 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 QVector<QPointF> &points = m_linePoints;
                 if (points.size() == 0) {
                     prepareGeometryChange();
                     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);
                     int size = m_linePen.width();
                     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), size, size);
                             fullPath.addEllipse(points.at(0), size, size);
                             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 &&currentGeometryPoint.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), size, size);
                             fullPath.addEllipse(points.at(i), size, size);
                             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));
                     if (m_pointsVisible) {
                         int size = m_linePen.width();
                         linePath.addEllipse(points.at(0), size, size);
                         linePath.moveTo(points.at(0));
                         for (int i = 1; i < points.size(); i++) {
                             linePath.lineTo(points.at(i));
                             linePath.addEllipse(points.at(i), size, size);
                             linePath.moveTo(points.at(i));
                         }
                     } else {
                         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);
                 // 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::handleUpdated()
             {
                 // If points visibility has changed, a geometry update is needed.
                 // Also, if pen changes when points are visible, geometry update is needed.
                 bool doGeometryUpdate =
                     (m_pointsVisible != m_series->pointsVisible())
                     || (m_series->pointsVisible() && (m_linePen != m_series->pen()));
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 m_pointLabelsClipping = m_series->pointLabelsClipping();
                 if (doGeometryUpdate)
                     updateGeometry();
                 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());
                 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);
                 }
                 reversePainter(painter, clipRect);
                 if (m_pointsVisible) {
                     painter->setBrush(m_linePen.color());
                     painter->drawPath(m_linePath);
                 } else {
                     painter->setBrush(QBrush(Qt::NoBrush));
                     if (m_linePen.style() != Qt::SolidLine || alwaysUsePath) {
                         // If pen style is not solid line, always fall back to path painting
                         // to ensure proper continuity of the pattern
                         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));
                     }
                 }
                 reversePainter(painter, clipRect);
                 if (m_pointLabelsVisible) {
                     if (m_pointLabelsClipping)
                         painter->setClipping(true);
                     else
                         painter->setClipping(false);
                     m_series->d_func()->drawSeriesPointLabels(painter, m_linePoints, m_linePen.width() / 2);
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 QGraphicsItem::mousePressEvent(event);
             }
             void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
                 if (m_mousePressed)
                     emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/scatterchart/scatterchartitem.cpp +3 -4

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/scatterchartitem_p.h>
             #include <QtCharts/QScatterSeries>
             #include <private/qscatterseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QChart>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsScene>
             #include <QtCore/QDebug>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_items(this),
                   m_visible(true),
                   m_shape(QScatterSeries::MarkerShapeRectangle),
                   m_size(15),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_pointLabelsClipping(true),
                   m_mousePressed(false)
             {
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsClippingChanged(bool)), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                     case QScatterSeries::MarkerShapeCircle: {
                         item = new CircleMarker(0, 0, m_size, m_size, this);
                         const QRectF &rect = item->boundingRect();
                         item->setPos(-rect.width() / 2, -rect.height() / 2);
                         break;
                     }
                     case QScatterSeries::MarkerShapeRectangle:
                         item = new RectangleMarker(0, 0, m_size, m_size, this);
                         item->setPos(-m_size / 2, -m_size / 2);
                         break;
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
             }
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
                 emit XYChart::clicked(m_markerMap[marker]);
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
                 emit XYChart::hovered(m_markerMap[marker], state);
             }
             void ScatterChartItem::markerPressed(QGraphicsItem *marker)
             {
                 emit XYChart::pressed(m_markerMap[marker]);
             }
             void ScatterChartItem::markerReleased(QGraphicsItem *marker)
             {
                 emit XYChart::released(m_markerMap[marker]);
             }
             void ScatterChartItem::markerDoubleClicked(QGraphicsItem *marker)
             {
                 emit XYChart::doubleClicked(m_markerMap[marker]);
             }
             void ScatterChartItem::updateGeometry()
             {
-                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
                 if (m_series->useOpenGL()) {
                     if (m_items.childItems().count())
                         deletePoints(m_items.childItems().count());
-                    // Fake a miniscule region, so we trigger changed signal.
+                    if (!m_rect.isEmpty()) {
-                    if (m_rect.width() != dummyRect.width()) {
                         prepareGeometryChange();
-                        m_rect = dummyRect;
+                        // Changed signal seems to trigger even with empty region
+                        m_rect = QRectF();
                     }
                     update();
                     return;
                 }
                 const QVector<QPointF>& points = geometryPoints();
                 if (points.size() == 0) {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if (diff > 0)
                     deletePoints(diff);
                 else if (diff < 0)
                     createPoints(-diff);
                 if (diff != 0)
                     handleUpdated();
                 QList<QGraphicsItem *> items = m_items.childItems();
                 QRectF clipRect(QPointF(0,0),domain()->size());
                 // Only zoom in if the clipRect fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (clipRect.height() <= INT_MAX
                         && clipRect.width() <= INT_MAX) {
                     QVector<bool> offGridStatus = offGridStatusVector();
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 0; i < points.size(); i++) {
                         QGraphicsItem *item = items.at(i);
                         const QPointF &point = points.at(i);
                         const QRectF &rect = item->boundingRect();
                         // During remove animation series may have different number of points,
                         // so ensure we don't go over the index. Animation handling itself ensures that
                         // if there is actually no points in the series, then it won't generate a fake point,
                         // so we can be assured there is always at least one point in m_series here.
                         // Note that marker map values can be technically incorrect during the animation,
                         // if it was caused by an insert, but this shouldn't be a problem as the points are
                         // fake anyway. After remove animation stops, geometry is updated to correct one.
                         m_markerMap[item] = m_series->at(qMin(seriesLastIndex, i));
                         QPointF position;
                         if (seriesPrivate()->reverseXAxis())
                             position.setX(domain()->size().width() - point.x() - rect.width() / 2);
                         else
                             position.setX(point.x() - rect.width() / 2);
                         if (seriesPrivate()->reverseYAxis())
                             position.setY(domain()->size().height() - point.y() - rect.height() / 2);
                         else
                             position.setY(point.y() - rect.height() / 2);
                         item->setPos(position);
                         if (!m_visible || offGridStatus.at(i))
                             item->setVisible(false);
                         else
                             item->setVisible(true);
                     }
                     prepareGeometryChange();
                     m_rect = clipRect;
                 }
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if (m_series->useOpenGL())
                     return;
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setClipRect(clipRect);
                 if (m_pointLabelsVisible) {
                     if (m_pointLabelsClipping)
                         painter->setClipping(true);
                     else
                         painter->setClipping(false);
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points,
                                                               m_series->markerSize() / 2
                                                               + m_series->pen().width());
                 }
                 painter->restore();
             }
             void ScatterChartItem::setPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
             void ScatterChartItem::setBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if (count == 0)
                     return;
                 bool recreate = m_visible != m_series->isVisible()
                                 || m_size != m_series->markerSize()
                                 || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 m_pointLabelsClipping = m_series->pointLabelsClipping();
                 if (recreate) {
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             #include "moc_scatterchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

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