HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2491:d86f47a4910b

Refactor the new QXYSeries::pointAt() -> QXYSeries::at()...

Miikka Heikkinen -

r2491:d86f47a4910b

parent child

Context file:

r2491:d86f47a4910b

Collapse all files

src/linechart/linechartitem.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "chartpresenter_p.h"
             #include "polardomain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_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)
             {
                 setAcceptHoverEvents(true);
                 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()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_shapePath;
             }
             void LineChartItem::updateGeometry()
             {
                 m_points = geometryPoints();
                 const QVector<QPointF> &points = m_points;
                 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->pointAt(0);
+                    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->pointAt(qMin(seriesLastIndex, i));
+                        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 = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
-                            qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->pointAt(i - 1).x(), dummyOk);
+                            qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
                             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());
                 prepareGeometryChange();
                 m_linePath = linePath;
                 m_fullPath = fullPath;
                 m_shapePath = stroker.createStroke(fullPath);
                 m_rect = m_shapePath.boundingRect();
             }
             void LineChartItem::handleUpdated()
             {
                 // If points visiblity 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();
                 if (doGeometryUpdate)
                     updateGeometry();
                 update();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 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);
                 }
                 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_points.size(); i++)
                             painter->drawLine(m_points.at(i - 1), m_points.at(i));
                     }
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
                 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);
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/scatterchartitem.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_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)
             {
                 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()));
                 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::updateGeometry()
             {
                 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());
                 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/append 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.
-                    m_markerMap[item] = m_series->pointAt(qMin(seriesLastIndex, i));
+                    m_markerMap[item] = m_series->at(qMin(seriesLastIndex, i));
                     item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
                     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(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             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());
                 if (recreate) {
                     // TODO: optimize handleUpdate to recreate points only in case shape changed
                     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"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem.cpp +3 -3

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "splineanimation_p.h"
             #include "polardomain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_animation(0)
             {
                 setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::SplineChartZValue);
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_fullPath;
             }
             void SplineChartItem::setAnimation(SplineAnimation *animation)
             {
                 m_animation = animation;
                 XYChart::setAnimation(animation);
             }
             ChartAnimation *SplineChartItem::animation() const
             {
                 return m_animation;
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints = points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 QVector<QPointF> controlPoints;
                 if (newPoints.count() >= 2)
                     controlPoints = calculateControlPoints(newPoints);
                 if (m_animation)
                     m_animation->setup(oldPoints, newPoints, m_controlPoints, controlPoints, index);
                 m_points = newPoints;
                 m_controlPoints = controlPoints;
                 setDirty(false);
                 if (m_animation)
                     presenter()->startAnimation(m_animation);
                 else
                     updateGeometry();
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = m_points;
                 const QVector<QPointF> &controlPoints = m_controlPoints;
                 if ((points.size() < 2) || (controlPoints.size() < 2)) {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count() * 2 - 2 == controlPoints.count());
                 QPainterPath splinePath;
                 QPainterPath fullPath;
                 // Use worst case scenario to determine required margin.
                 qreal margin = m_linePen.width() * 1.42;
                 if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
                     QPainterPath splinePathLeft;
                     QPainterPath splinePathRight;
                     QPainterPath *currentSegmentPath = 0;
                     QPainterPath *previousSegmentPath = 0;
                     qreal minX = domain()->minX();
                     qreal maxX = domain()->maxX();
                     qreal minY = domain()->minY();
-                    QPointF currentSeriesPoint = m_series->pointAt(0);
+                    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);
                     m_visiblePoints.clear();
                     m_visiblePoints.reserve(points.size());
                     qreal domainRadius = domain()->size().height() / 2.0;
                     const QPointF centerPoint(domainRadius, domainRadius);
                     if (!previousPointWasOffGrid) {
                         fullPath.moveTo(points.at(0));
                         // Do not draw points for points below minimum Y.
                         if (m_pointsVisible && currentSeriesPoint.y() >= minY)
                             m_visiblePoints.append(currentGeometryPoint);
                     }
                     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 spline fragments accurately is not trivial, and would anyway be ugly
                         // when thick pen is used, so we work around it by utilizing three separate
                         // paths for spline 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->pointAt(qMin(seriesLastIndex, i));
+                        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) {
                             bool dummyOk; // We know points are ok, but this is needed
                             qreal currentAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
-                            qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->pointAt(i - 1).x(), dummyOk);
+                            qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
                             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 = &splinePathRight;
                                 } else if ((previousAngle > 360.0 || (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
                                             && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathLeft;
                                 } else if (previousAngle > 0.0 && previousAngle < 360.0) {
                                     currentSegmentPath = &splinePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(previousGeometryPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(previousGeometryPoint);
                                     currentSegmentPath->lineTo(centerPoint);
                                     fullPath.lineTo(centerPoint);
                                 }
                                 previousSegmentPath = currentSegmentPath;
                                 if ((currentAngle < 0.0 || (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
                                     && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathRight;
                                 } else if ((currentAngle > 360.0 || (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
                                             && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathLeft;
                                 } else if (currentAngle > 0.0 && currentAngle < 360.0) {
                                     currentSegmentPath = &splinePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(centerPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(centerPoint);
                                     currentSegmentPath->lineTo(currentGeometryPoint);
                                     fullPath.lineTo(currentGeometryPoint);
                                 }
                             } else {
                                 QPointF cp1 = controlPoints[2 * (i - 1)];
                                 QPointF cp2 = controlPoints[(2 * i) - 1];
                                 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 = &splinePathRight;
                                 } 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 = &splinePathLeft;
                                 } else {
                                     currentSegmentPath = &splinePath;
                                 }
                                 if (currentSegmentPath != previousSegmentPath)
                                     currentSegmentPath->moveTo(previousGeometryPoint);
                                 if (!previousSegmentPath)
                                     fullPath.moveTo(previousGeometryPoint);
                                 fullPath.cubicTo(cp1, cp2, currentGeometryPoint);
                                 currentSegmentPath->cubicTo(cp1, cp2, currentGeometryPoint);
                             }
                         } else {
                             currentSegmentPath = 0;
                         }
                         previousPointWasOffGrid = pointOffGrid;
                         if (!pointOffGrid && m_pointsVisible && currentSeriesPoint.y() >= minY)
                             m_visiblePoints.append(currentGeometryPoint);
                         previousSegmentPath = currentSegmentPath;
                         previousGeometryPoint = currentGeometryPoint;
                     }
                     m_pathPolarRight = splinePathRight;
                     m_pathPolarLeft = splinePathLeft;
                     // 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
                     splinePath.moveTo(points.at(0));
                     for (int i = 0; i < points.size() - 1; i++) {
                         const QPointF &point = points.at(i + 1);
                         splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);
                     }
                     fullPath = splinePath;
                 }
                 m_path = splinePath;
                 QPainterPathStroker stroker;
                 // The full path is comprised of three separate paths.
                 // 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());
                 prepareGeometryChange();
                 m_fullPath = stroker.createStroke(fullPath);
                 m_rect = m_fullPath.boundingRect();
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             QVector<QPointF> SplineChartItem::calculateControlPoints(const QVector<QPointF> &points)
             {
                 QVector<QPointF> controlPoints;
                 controlPoints.resize(points.count() * 2 - 2);
                 int n = points.count() - 1;
                 if (n == 1) {
                     //for n==1
                     controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     controlPoints[1].setX(2 * controlPoints[0].x() - points[0].x());
                     controlPoints[1].setY(2 * controlPoints[0].y() - points[0].y());
                     return controlPoints;
                 }
                 // Calculate first Bezier control points
                 // Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 vector[n - 1] = (8 * points[n - 1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 vector[n - 1] = (8 * points[n - 1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0, j = 0; i < n; ++i, ++j) {
                     controlPoints[j].setX(xControl[i]);
                     controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1) {
                         controlPoints[j].setX(2 * points[i + 1].x() - xControl[i + 1]);
                         controlPoints[j].setY(2 * points[i + 1].y() - yControl[i + 1]);
                     } else {
                         controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
                 return controlPoints;
             }
             QVector<qreal> SplineChartItem::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i] = (vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(Qt::NoBrush);
                 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_pathPolarLeft);
                     painter->setClipRegion(clipRegionRight);
                     painter->drawPath(m_pathPolarRight);
                     painter->setClipRegion(fullPolarClipRegion);
                 } else {
                     painter->setClipRect(clipRect);
                 }
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     if (m_series->chart()->chartType() == QChart::ChartTypePolar)
                         painter->drawPoints(m_visiblePoints);
                     else
                         painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             void SplineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void SplineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
                 QGraphicsItem::hoverLeaveEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
             #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with another points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points. This is faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
-            const QPointF &QXYSeries::pointAt(int index) const
+            const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new XYAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QXYSeries();
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> &points);
                 void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
                 void replace(const QPointF &oldPoint, const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
-                const QPointF &pointAt(int index) const;
+                const QPointF &at(int index) const;
                 QXYSeries &operator << (const QPointF &point);
                 QXYSeries &operator << (const QList<QPointF> &points);
                 virtual void setPen(const QPen &pen);
                 QPen pen() const;
                 virtual void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 virtual void setColor(const QColor &color);
                 virtual QColor color() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 void replace(QList<QPointF> points);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void hovered(const QPointF &point, bool state);
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
                 void colorChanged(QColor color);
                 void pointsReplaced();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class QXYLegendMarkerPrivate;
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYSERIES_H

src/xychart/xychart.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include "qxymodelmapper.h"
             #include "qabstractaxis_p.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
                   ChartItem(series->d_func(),item),
                   m_series(series),
                   m_animation(0),
                   m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF> &points)
             {
                 m_points = points;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             // Returns a vector with same size as geometryPoints vector, indicating
             // the off grid status of points.
             QVector<bool> XYChart::offGridStatusVector()
             {
                 qreal minX = domain()->minX();
                 qreal maxX = domain()->maxX();
                 qreal minY = domain()->minY();
                 qreal maxY = domain()->maxY();
                 QVector<bool> returnVector;
                 returnVector.resize(m_points.size());
                 // During remove/append 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->pointAt(qMin(seriesLastIndex, 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(QVector<QPointF> &oldPoints, QVector<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();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<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()[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);
                 QVector<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::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty || m_points.isEmpty()) {
                     points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
                     QPointF point = domain()->calculateGeometryPoint(m_series->points()[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()
             {
                 // All the points were replaced -> recalculate
                 QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
                 updateChart(m_points, points, -1);
             }
             void XYChart::handleDomainUpdated()
             {
                 if (isEmpty()) return;
                 QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
                 updateChart(m_points, points);
             }
             bool XYChart::isEmpty()
             {
                 return domain()->isEmpty() || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_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