HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2746:4909289ecbd7

Fix clicked, released and doubleClicked signal points...

Titta Heikkala -

r2746:4909289ecbd7

parent child

Context file:

r2746:4909289ecbd7

Collapse all files

src/charts/areachart/areachartitem.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/areachartitem_p.h>
             #include <QtCharts/QAreaSeries>
             #include <private/qareaseries_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item)
                 : ChartItem(areaSeries->d_func(),item),
                   m_series(areaSeries),
                   m_upper(0),
                   m_lower(0),
                   m_pointsVisible(false),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(areaSeries->pointLabelsFormat()),
                   m_pointLabelsFont(areaSeries->pointLabelsFont()),
                   m_pointLabelsColor(areaSeries->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable, true);
                 setZValue(ChartPresenter::LineChartZValue);
                 if (m_series->upperSeries())
                     m_upper = new AreaBoundItem(this, m_series->upperSeries());
                 if (m_series->lowerSeries())
                     m_lower = new AreaBoundItem(this, m_series->lowerSeries());
                 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(this, SIGNAL(clicked(QPointF)), areaSeries, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), areaSeries, SIGNAL(hovered(QPointF,bool)));
                 QObject::connect(this, SIGNAL(pressed(QPointF)), areaSeries, SIGNAL(pressed(QPointF)));
                 QObject::connect(this, SIGNAL(released(QPointF)), areaSeries, SIGNAL(released(QPointF)));
                 QObject::connect(this, SIGNAL(doubleClicked(QPointF)),
                                  areaSeries, SIGNAL(doubleClicked(QPointF)));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFontChanged(QFont)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsColorChanged(QColor)),
                                  this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             void AreaChartItem::setPresenter(ChartPresenter *presenter)
             {
                 if (m_upper)
                     m_upper->setPresenter(presenter);
                 if (m_lower) {
                     m_lower->setPresenter(presenter);
                 }
             	ChartItem::setPresenter(presenter);
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 QRectF rect(QPointF(0,0),domain()->size());
                 path = m_upper->path();
                 if (m_lower) {
                     // Note: Polarcharts always draw area correctly only when both series have equal width or are
                     // fully displayed. If one series is partally off-chart, the connecting line between
                     // the series does not attach to the end of the partially hidden series but to the point
                     // where it intersects the axis line. The problem is especially noticeable when one of the series
                     // is entirely off-chart, in which case the connecting line connects two ends of the
                     // visible series.
                     // This happens because we get the paths from linechart, which omits off-chart segments.
                     // To properly fix, linechart would need to provide true full path, in right, left, and the rest
                     // portions to enable proper clipping. However, combining those to single visually unified area
                     // would be a nightmare, since they would have to be painted separately.
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     if (presenter()->chartType() == QChart::ChartTypeCartesian) {
                         path.lineTo(last.x(), rect.bottom());
                         path.lineTo(first.x(), rect.bottom());
                     } else { // polar
                         path.lineTo(rect.center());
                     }
                 }
                 path.closeSubpath();
                 // Only zoom in if the bounding rect of the path fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (path.boundingRect().height() <= INT_MAX
                         && path.boundingRect().width() <= INT_MAX) {
                     prepareGeometryChange();
                     m_path = path;
                     m_rect = path.boundingRect();
                     update();
                 }
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 if (m_upper) {
                     AbstractDomain* d = m_upper->domain();
                     d->setSize(domain()->size());
                     d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                     m_upper->handleDomainUpdated();
                 }
                 if (m_lower) {
                     AbstractDomain* d = m_lower->domain();
                     d->setSize(domain()->size());
                     d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                     m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 if (presenter()->chartType() == QChart::ChartTypePolar)
                     painter->setClipRegion(QRegion(clipRect.toRect(), QRegion::Ellipse));
                 else
                     painter->setClipRect(clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(m_upper->geometryPoints());
                     if (m_lower)
                         painter->drawPoints(m_lower->geometryPoints());
                 }
                 // Draw series point label
                 if (m_pointLabelsVisible) {
                     static const QString xPointTag(QLatin1String("@xPoint"));
                     static const QString yPointTag(QLatin1String("@yPoint"));
                     const int labelOffset = 2;
                     painter->setFont(m_pointLabelsFont);
                     painter->setPen(QPen(m_pointLabelsColor));
                     QFontMetrics fm(painter->font());
                     QString pointLabel = m_pointLabelsFormat;
                     if (m_series->upperSeries()) {
                         for (int i(0); i < m_series->upperSeries()->count(); i++) {
                             pointLabel.replace(xPointTag,
                                                presenter()->numberToString(m_series->upperSeries()->at(i).x()));
                             pointLabel.replace(yPointTag,
                                                presenter()->numberToString(m_series->upperSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_upper->geometryPoints().at(i));
                             position.setX(position.x() - pointLabelWidth / 2);
                             position.setY(position.y() - m_series->upperSeries()->pen().width() / 2 - labelOffset);
                             painter->drawText(position, pointLabel);
                         }
                     }
                     if (m_series->lowerSeries()) {
                         for (int i(0); i < m_series->lowerSeries()->count(); i++) {
                             pointLabel.replace(xPointTag,
                                                presenter()->numberToString(m_series->lowerSeries()->at(i).x()));
                             pointLabel.replace(yPointTag,
                                                presenter()->numberToString(m_series->lowerSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_lower->geometryPoints().at(i));
                             position.setX(position.x() - pointLabelWidth / 2);
                             position.setY(position.y() - m_series->lowerSeries()->pen().width() / 2 - labelOffset);
                             painter->drawText(position, pointLabel);
                         }
                     }
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit pressed(m_upper->domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 ChartItem::mousePressEvent(event);
             }
             void AreaChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit released(m_upper->domain()->calculateDomainPoint(event->pos()));
+                emit released(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
-                    emit clicked(m_upper->domain()->calculateDomainPoint(event->pos()));
+                    emit clicked(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 ChartItem::mouseReleaseEvent(event);
             }
             void AreaChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit doubleClicked(m_upper->domain()->calculateDomainPoint(event->pos()));
+                emit doubleClicked(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
                 ChartItem::mouseDoubleClickEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/areachart/qareaseries.cpp +19 -6

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAreaSeries>
             #include <private/qareaseries_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/areachartitem_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QAreaLegendMarker>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \inmodule Qt Charts
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
                 An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
                 is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
                 which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                 In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
                 where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmltype AreaSeries
                 \instantiates QAreaSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The AreaSeries type is used for making area charts.
                 The following QML shows how to create a simple area chart:
                 \snippet qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image examples_qmlchart4.png
                 \endfloat
                 \clearfloat
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was constructed without a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was constructed without a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                 \qmlproperty real AreaSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \qmlproperty QString AreaSeries::brushFilename
                 The name of the file used as a brush image for the series.
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
-                \brief Signal is emitted when user clicks the \a point on area chart.
+                \brief Signal is emitted when user clicks the \a point on area chart. The \a point is the point
+                where the press was triggered.
+                \sa pressed, released, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onClicked(QPointF point)
-                Signal is emitted when user clicks the \a point on area chart.
+                Signal is emitted when user clicks the \a point on area chart. The \a point is the point where
+                the press was triggered.
+                \sa onPressed, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::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 AreaSeries::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 QAreaSeries::pressed(const QPointF& point)
                 \brief Signal is emitted when user presses the \a point on area chart.
+                \sa clicked, released, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onPressed(QPointF point)
                 Signal is emitted when user presses the \a point on area chart.
+                \sa onClicked, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::released(const QPointF& point)
-                \brief Signal is emitted when user releases the \a point on area chart.
+                \brief Signal is emitted when user releases a press that was triggered on a \a point on area
+                chart.
+                \sa pressed, clicked, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onReleased(QPointF point)
-                Signal is emitted when user releases the \a point on area chart.
+                Signal is emitted when user releases a press that was triggered on a \a point on area chart.
+                \sa onPressed, onClicked, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::doubleClicked(const QPointF& point)
-                \brief Signal is emitted when user doubleclicks the \a point on area chart.
+                \brief Signal is emitted when user doubleclicks the \a point on area chart. The \a point is the
+                point where the first press was triggered.
+                \sa pressed, released, clicked
             */
             /*!
                 \qmlsignal AreaSeries::onDoubleClicked(QPointF point)
-                Signal is emitted when user doubleclicks the \a point on area chart.
+                Signal is emitted when user doubleclicks the \a point on area chart. The \a point is the point
+                where the first press was triggered.
+                \sa onPressed, onReleased, onClicked
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \property QAreaSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QAreaSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa QAreaSeries::pointLabelsVisible, QAreaSeries::pointLabelsFont, QAreaSeries::pointLabelsColor
             */
             /*!
                 \qmlproperty string AreaSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa QAreaSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QAreaSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QAreaSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa QAreaSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty bool AreaSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QAreaSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QAreaSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa QAreaSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font AreaSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QAreaSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QAreaSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa QAreaSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font AreaSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QAreaSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries, lowerSeries, this), upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QAbstractSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
                 if (d->m_upperSeries != series)
                     d->m_upperSeries = series;
             }
             QLineSeries *QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries *QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = brush.color() != d->m_brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             void QAreaSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QAreaSeries::pointLabelsFormat() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsFormat;
             }
             void QAreaSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QAreaSeries::pointLabelsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsVisible;
             }
             void QAreaSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QAreaSeries::pointLabelsFont() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsFont;
             }
             void QAreaSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QAreaSeries::pointLabelsColor() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pen(QChartPrivate::defaultPen()),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color())
             {
             }
             void QAreaSeriesPrivate::initializeDomain()
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 QLineSeries *upperSeries = q->upperSeries();
                 QLineSeries *lowerSeries = q->lowerSeries();
                 if (upperSeries) {
                     const QList<QPointF>& points = upperSeries->points();
                     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);
                     }
                 }
                 if (lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     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);
             }
             void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = new AreaChartItem(q,parent);
                 m_item.reset(area);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                 if (q->upperSeries() && area->upperLineItem()->animation())
                     area->upperLineItem()->animation()->stopAndDestroyLater();
                 if (q->lowerSeries() && area->lowerLineItem()->animation())
                     area->lowerLineItem()->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if (q->lowerSeries())
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                 } else {
                     if (q->upperSeries())
                         area->upperLineItem()->setAnimation(0);
                     if (q->lowerSeries())
                            area->lowerLineItem()->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<QLegendMarker*> list;
                 return list << new QAreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return new QValueAxis;
             }
             void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QAreaSeries);
                 const QList<QGradient> gradients = theme->seriesGradients();
                 const QList<QColor> colors = theme->seriesColors();
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen;
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
                 if (forced || QChartPrivate::defaultPen().color() == m_pointLabelsColor) {
                     QColor color = theme->labelBrush().color();
                     q->setPointLabelsColor(color);
                 }
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/bar.cpp +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/bar_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneEvent>
             #include <QtWidgets/QStyleOptionGraphicsItem>
             #include <QtWidgets/QStyle>
             QT_CHARTS_BEGIN_NAMESPACE
             Bar::Bar(QBarSet *barset, int index, QGraphicsItem *parent) : QGraphicsRectItem(parent),
                 m_index(index),
                 m_barset(barset),
                 m_hovering(false),
                 m_mousePressed(false)
             {
                 setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
             }
             Bar::~Bar()
             {
                 // End hover event, if bar is deleted during it
                 if (m_hovering)
                     emit hovered(false, m_index, m_barset);
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit pressed(m_index, m_barset);
-                m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 QGraphicsItem::mousePressEvent(event);
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = true;
                 emit hovered(true, m_index, m_barset);
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = false;
                 emit hovered(false, m_index, m_barset);
             }
             void Bar::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit released(m_index, m_barset);
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
                     emit clicked(m_index, m_barset);
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void Bar::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit doubleClicked(m_index, m_barset);
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 // Remove selection border around bar
                 QStyleOptionGraphicsItem barOption(*option);
                 barOption.state &= ~QStyle::State_Selected;
                 QGraphicsRectItem::paint(painter, &barOption, widget);
             }
             #include "moc_bar_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/bar_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BAR_H
             #define BAR_H
             #include <QtCharts/QChartGlobal>
             #include <QtWidgets/QGraphicsRectItem>
             QT_CHARTS_BEGIN_NAMESPACE
             class QBarSet;
             // Single visual bar item of chart
             class Bar : public QObject, public QGraphicsRectItem
             {
                 Q_OBJECT
             public:
                 Bar(QBarSet *barset, int index, QGraphicsItem *parent = 0);
                 ~Bar();
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
                 void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void hovered(bool status, int index, QBarSet *barset);
                 void pressed(int index, QBarSet *barset);
                 void released(int index, QBarSet *barset);
                 void doubleClicked(int index, QBarSet *barset);
             private:
                 int m_index;
                 QBarSet *m_barset;
                 bool m_hovering;
-                QPointF m_lastMousePos;
                 bool m_mousePressed;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // BAR_H

src/charts/boxplotchart/boxwhiskers.cpp +3 -2

             /****************************************************************************
              **
              ** Copyright (C) 2014 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, 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 Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/boxwhiskers_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QWidget>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             BoxWhiskers::BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 m_boxSet(set),
                 m_domain(domain),
                 m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setFlag(QGraphicsObject::ItemIsSelectable);
             }
             BoxWhiskers::~BoxWhiskers()
             {
             }
             void BoxWhiskers::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
+                Q_UNUSED(event)
                 emit pressed(m_boxSet);
-                m_lastMousePos = event->pos();
                 m_mousePressed = true;
             }
             void BoxWhiskers::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 emit hovered(true, m_boxSet);
             }
             void BoxWhiskers::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 emit hovered(false, m_boxSet);
             }
             void BoxWhiskers::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
+                Q_UNUSED(event)
                 emit released(m_boxSet);
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
                     emit clicked(m_boxSet);
             }
             void BoxWhiskers::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
                 // For Box a press signal needs to be explicitly fired for mouseDoubleClickEvent
                 emit pressed(m_boxSet);
                 emit doubleClicked(m_boxSet);
             }
             void BoxWhiskers::setBrush(const QBrush &brush)
             {
                 m_brush = brush;
                 m_outlinePen.setColor(m_brush.color());
                 update();
             }
             void BoxWhiskers::setPen(const QPen &pen)
             {
                 qreal widthDiff = pen.widthF() - m_pen.widthF();
                 m_boundingRect.adjust(-widthDiff, -widthDiff, widthDiff, widthDiff);
                 m_pen = pen;
                 m_medianPen = pen;
                 m_medianPen.setCapStyle(Qt::FlatCap);
                 m_outlinePen = pen;
                 m_outlinePen.setStyle(Qt::SolidLine);
                 m_outlinePen.setColor(m_brush.color());
                 update();
             }
             void BoxWhiskers::setBoxWidth(const qreal width)
             {
                 m_boxWidth = width;
             }
             void BoxWhiskers::setLayout(const BoxWhiskersData &data)
             {
                 m_data = data;
                 updateGeometry(m_domain);
                 update();
             }
             QSizeF BoxWhiskers::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which)
                 Q_UNUSED(constraint)
                 return QSizeF();
             }
             void BoxWhiskers::setGeometry(const QRectF &rect)
             {
                 Q_UNUSED(rect)
             }
             QRectF BoxWhiskers::boundingRect() const
             {
                 return m_boundingRect;
             }
             void BoxWhiskers::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 painter->save();
                 painter->setBrush(m_brush);
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_pen);
                 painter->drawPath(m_boxPath);
                 if (!m_boxOutlined)
                     painter->setPen(m_outlinePen);
                 painter->drawRect(m_middleBox);
                 painter->setPen(m_medianPen);
                 qreal halfLine = m_pen.widthF() / 2.0;
                 painter->drawLine(QLineF(m_geometryLeft - halfLine, m_geometryMedian,
                                          m_geometryRight + halfLine, m_geometryMedian));
                 painter->restore();
             }
             void BoxWhiskers::updateGeometry(AbstractDomain *domain)
             {
                 m_domain = domain;
                 prepareGeometryChange();
                 QPainterPath path;
                 m_boxPath = path;
                 m_boundingRect = m_boxPath.boundingRect();
                 qreal columnWidth = 1.0 / m_data.m_seriesCount;
                 qreal left = ((1.0 - m_boxWidth) / 2.0) * columnWidth + columnWidth * m_data.m_seriesIndex + m_data.m_index - 0.5;
                 qreal barWidth = m_boxWidth * columnWidth;
                 QPointF geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_upperExtreme), m_validData);
                 if (!m_validData)
                     return;
                 m_geometryLeft = geometryPoint.x();
                 qreal geometryUpperExtreme = geometryPoint.y();
                 geometryPoint = m_domain->calculateGeometryPoint(QPointF(left + barWidth, m_data.m_upperQuartile), m_validData);
                 if (!m_validData)
                     return;
                 m_geometryRight = geometryPoint.x();
                 qreal geometryUpperQuartile = geometryPoint.y();
                 geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_lowerQuartile), m_validData);
                 if (!m_validData)
                     return;
                 qreal geometryLowerQuartile = geometryPoint.y();
                 geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_lowerExtreme), m_validData);
                 if (!m_validData)
                     return;
                 qreal geometryLowerExtreme = geometryPoint.y();
                 geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_median), m_validData);
                 if (!m_validData)
                     return;
                 m_geometryMedian = geometryPoint.y();
                 // Upper whisker
                 path.moveTo(m_geometryLeft, geometryUpperExtreme);
                 path.lineTo(m_geometryRight, geometryUpperExtreme);
                 path.moveTo((m_geometryLeft + m_geometryRight) / 2.0, geometryUpperExtreme);
                 path.lineTo((m_geometryLeft + m_geometryRight) / 2.0, geometryUpperQuartile);
                 // Middle Box
                 m_middleBox.setCoords(m_geometryLeft, geometryUpperQuartile, m_geometryRight, geometryLowerQuartile);
                 // Lower whisker
                 path.moveTo(m_geometryLeft, geometryLowerExtreme);
                 path.lineTo(m_geometryRight, geometryLowerExtreme);
                 path.moveTo((m_geometryLeft + m_geometryRight) / 2.0, geometryLowerQuartile);
                 path.lineTo((m_geometryLeft + m_geometryRight) / 2.0, geometryLowerExtreme);
                 path.closeSubpath();
                 m_boxPath = path;
                 m_boundingRect = m_boxPath.boundingRect();
                 qreal extra = m_pen.widthF();
                 m_boundingRect.adjust(-extra, -extra, extra, extra);
             }
             #include "moc_boxwhiskers_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/boxplotchart/boxwhiskers_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BOXWHISKERS_H
             #define BOXWHISKERS_H
             #include <private/boxwhiskersdata_p.h>
             #include <QtCharts/QChartGlobal>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QBoxSet>
             #include <QtWidgets/QGraphicsRectItem>
             #include <QtWidgets/QGraphicsLineItem>
             #include <QtWidgets/QGraphicsLayoutItem>
             #include <QtGui/QPainterPath>
             QT_CHARTS_BEGIN_NAMESPACE
             class QBarSet;
             class BoxWhiskers : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent);
                 ~BoxWhiskers();
                 void setBrush(const QBrush &brush);
                 void setPen(const QPen &pen);
                 void setLayout(const BoxWhiskersData &data);
                 void setBoxOutlined(const bool outlined) { m_boxOutlined = outlined; }
                 void setBoxWidth(const qreal width);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
                 void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 void updateGeometry(AbstractDomain *domain);
             protected:
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
                 void setGeometry(const QRectF &rect);
             Q_SIGNALS:
                 void clicked(QBoxSet *boxset);
                 void hovered(bool status, QBoxSet *boxset);
                 void pressed(QBoxSet *boxset);
                 void released(QBoxSet *boxset);
                 void doubleClicked(QBoxSet *boxset);
             private:
                 friend class BoxPlotChartItem;
                 friend class BoxPlotAnimation;
                 QBoxSet *m_boxSet;
                 AbstractDomain *m_domain;
                 QPainterPath    m_boxPath;
                 QRectF m_boundingRect;
                 bool m_hovering;
                 bool m_validData;
                 QBrush  m_brush;
                 QPen m_pen;
                 QPen m_medianPen;
                 QPen m_outlinePen;
                 bool m_boxOutlined;
                 qreal m_boxWidth;
                 BoxWhiskersData m_data;
                 QSizeF m_domainSize;
                 QRectF m_middleBox;
                 qreal m_geometryMedian;
                 qreal m_geometryLeft;
                 qreal m_geometryRight;
-                QPointF m_lastMousePos;
                 bool m_mousePressed;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // BOXWHISKERS_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** 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_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()));
                 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->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 = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.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());
                 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();
                 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));
                     }
                 }
                 if (m_pointLabelsVisible)
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points, 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(event->pos()));
+                emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
-                    emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
+                    emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit XYChart::doubleClicked(domain()->calculateDomainPoint(event->pos()));
+                emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/piechart/piesliceitem.cpp +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/piesliceitem_p.h>
             #include <private/piechartitem_p.h>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QPieSlice>
             #include <private/chartpresenter_p.h>
             #include <QtGui/QPainter>
             #include <QtCore/QtMath>
             #include <QtWidgets/QGraphicsSceneEvent>
             #include <QtCore/QTime>
             #include <QtGui/QTextDocument>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle * (M_PI / 180)) * length;
                 qreal dy = qCos(angle * (M_PI / 180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                   m_hovered(false),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 m_labelItem = new QGraphicsTextItem(this);
                 m_labelItem->document()->setDocumentMargin(1.0);
             }
             PieSliceItem::~PieSliceItem()
             {
                 // If user is hovering over the slice and it gets destroyed we do
                 // not get a hover leave event. So we must emit the signal here.
                 if (m_hovered)
                     emit hovered(false);
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSliceItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->save();
                     // Pen for label arm not defined in the QPieSeries api, let's use brush's color instead
                     painter->setBrush(m_data.m_labelBrush);
                     if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
                         painter->setClipRect(parentItem()->boundingRect());
                         painter->strokePath(m_labelArmPath, m_data.m_labelBrush.color());
                     }
                     painter->restore();
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/)
             {
                 m_hovered = true;
                 emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/)
             {
                 m_hovered = false;
                 emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit pressed(event->buttons());
-                m_lastMousePos = event->pos();
                 m_mousePressed = true;
             }
             void PieSliceItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit released(event->buttons());
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
                     emit clicked(event->buttons());
             }
             void PieSliceItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 // For Pie slice a press signal needs to be explicitly fired for mouseDoubleClickEvent
                 emit pressed(event->buttons());
                 emit doubleClicked(event->buttons());
             }
             void PieSliceItem::setLayout(const PieSliceData &sliceData)
             {
                 m_data = sliceData;
                 updateGeometry();
                 update();
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 m_labelItem->setVisible(m_data.m_isLabelVisible);
                 if (m_data.m_isLabelVisible) {
                     // text rect
                     m_labelTextRect = ChartPresenter::textBoundingRect(m_data.m_labelFont,
                                                                        m_data.m_labelText,
 );
                     QString label(m_data.m_labelText);
                     m_labelItem->setDefaultTextColor(m_data.m_labelBrush.color());
                     m_labelItem->setFont(m_data.m_labelFont);
                     // text position
                     if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
                         setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
                         // label arm path
                         QPointF labelTextStart;
                         m_labelArmPath = labelArmPath(armStart, centerAngle,
                                                       m_data.m_radius * m_data.m_labelArmLengthFactor,
                                                       m_labelTextRect.width(), &labelTextStart);
                         m_labelTextRect.moveBottomLeft(labelTextStart);
                         if (m_labelTextRect.left() < 0)
                             m_labelTextRect.setLeft(0);
                         else if (m_labelTextRect.left() < parentItem()->boundingRect().left())
                             m_labelTextRect.setLeft(parentItem()->boundingRect().left());
                         if (m_labelTextRect.right() > parentItem()->boundingRect().right())
                             m_labelTextRect.setRight(parentItem()->boundingRect().right());
                         label = ChartPresenter::truncatedText(m_data.m_labelFont, m_data.m_labelText,
                                                               qreal(0.0), m_labelTextRect.width(),
                                                               m_labelTextRect.height(), m_labelTextRect);
                         m_labelArmPath = labelArmPath(armStart, centerAngle,
                                                       m_data.m_radius * m_data.m_labelArmLengthFactor,
                                                       m_labelTextRect.width(), &labelTextStart);
                         m_labelTextRect.moveBottomLeft(labelTextStart);
                         m_labelItem->setTextWidth(m_labelTextRect.width()
                                                   + m_labelItem->document()->documentMargin());
                         m_labelItem->setHtml(label);
                         m_labelItem->setRotation(0);
                         m_labelItem->setPos(m_labelTextRect.x(), m_labelTextRect.y() + 1.0);
                     } else {
                         // label inside
                         setFlag(QGraphicsItem::ItemClipsChildrenToShape);
                         m_labelItem->setTextWidth(m_labelTextRect.width()
                                                   + m_labelItem->document()->documentMargin());
                         m_labelItem->setHtml(label);
                         QPointF textCenter;
                         if (m_data.m_holeRadius > 0) {
                             textCenter = m_data.m_center + offset(centerAngle, m_data.m_holeRadius
                                                                   + (m_data.m_radius
                                                                      - m_data.m_holeRadius) / 2);
                         } else {
                             textCenter = m_data.m_center + offset(centerAngle, m_data.m_radius / 2);
                         }
                         m_labelItem->setPos(textCenter.x() - m_labelItem->boundingRect().width() / 2,
                                             textCenter.y() - m_labelTextRect.height() / 2);
                         QPointF labelCenter = m_labelItem->boundingRect().center();
                         m_labelItem->setTransformOriginPoint(labelCenter);
                         if (m_data.m_labelPosition == QPieSlice::LabelInsideTangential) {
                             m_labelItem->setRotation(m_data.m_startAngle + m_data.m_angleSpan / 2);
                         } else if (m_data.m_labelPosition == QPieSlice::LabelInsideNormal) {
                             if (m_data.m_startAngle + m_data.m_angleSpan / 2 < 180)
                                 m_labelItem->setRotation(m_data.m_startAngle + m_data.m_angleSpan / 2 - 90);
                             else
                                 m_labelItem->setRotation(m_data.m_startAngle + m_data.m_angleSpan / 2 + 90);
                         } else {
                             m_labelItem->setRotation(0);
                         }
                     }
                     // Hide label if it's outside the bounding rect of parent item
                     QRectF labelRect(m_labelItem->boundingRect());
                     labelRect.moveTopLeft(m_labelItem->pos());
                     if ((parentItem()->boundingRect().left()
                                 < (labelRect.left() + m_labelItem->document()->documentMargin() + 1.0))
                             && (parentItem()->boundingRect().right()
                                 > (labelRect.right() - m_labelItem->document()->documentMargin() - 1.0))
                             && (parentItem()->boundingRect().top()
                                 < (labelRect.top() + m_labelItem->document()->documentMargin() + 1.0))
                             && (parentItem()->boundingRect().bottom()
                                 > (labelRect.bottom() - m_labelItem->document()->documentMargin() - 1.0)))
                         m_labelItem->show();
                     else
                         m_labelItem->hide();
                 }
                 //  bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
                 // Inflate bounding rect by 2/3 pen width to make sure it encompasses whole slice also for thick pens
                 // and miter joins.
                 int penWidth = (m_data.m_slicePen.width() * 2) / 3;
                 m_boundingRect = m_boundingRect.adjusted(-penWidth, -penWidth, penWidth, penWidth);
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + (slice->angleSpan() / 2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     point += offset(centerAngle, len);
                 }
                 return point;
             }
             QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan / 2);
                 // calculate slice rectangle
                 QRectF rect(center.x() - radius, center.y() - radius, radius * 2, radius * 2);
                 // slice path
                 QPainterPath path;
                 if (m_data.m_holeRadius > 0) {
                     QRectF insideRect(center.x() - m_data.m_holeRadius, center.y() - m_data.m_holeRadius, m_data.m_holeRadius * 2, m_data.m_holeRadius * 2);
                     path.arcMoveTo(rect, -startAngle + 90);
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.arcTo(insideRect, -startAngle + 90 - angleSpan, angleSpan);
                     path.closeSubpath();
                 } else {
                     path.moveTo(rect.center());
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.closeSubpath();
                 }
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // Normalize the angle to 0-360 range
                 // NOTE: We are using int here on purpose. Depenging on platform and hardware
                 // qreal can be a double, float or something the user gives to the Qt configure
                 // (QT_COORD_TYPE). Compilers do not seem to support modulo for double or float
                 // but there are fmod() and fmodf() functions for that. So instead of some #ifdef
                 // that might break we just use int. Precision for this is just fine for our needs.
                 int normalized = angle * 10.0;
                 normalized = normalized % 3600;
                 if (normalized < 0)
                     normalized += 3600;
                 angle = (qreal) normalized / 10.0;
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 QPointF parm1 = start + offset(angle, length);
                 // line to underline the label
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                     parm2 += QPointF(textWidth, 0);
                     *textStart = parm1;
                 } else {
                     parm2 += QPointF(-textWidth, 0);
                     *textStart = parm2;
                 }
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             #include "moc_piesliceitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/piechart/piesliceitem_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PIESLICEITEM_H
             #define PIESLICEITEM_H
             #include <QtCharts/QChartGlobal>
             #include <private/charttheme_p.h>
             #include <QtCharts/QPieSeries>
             #include <private/pieslicedata_p.h>
             #include <QtWidgets/QGraphicsItem>
             #include <QtCore/QRectF>
             #include <QtGui/QColor>
             #include <QtGui/QPen>
             #define PIESLICE_LABEL_GAP 5
             QT_CHARTS_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceItem : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSliceItem(QGraphicsItem *parent = 0);
                 ~PieSliceItem();
                 // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
                 void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
                 void setLayout(const PieSliceData &sliceData);
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
                 void hovered(bool state);
                 void pressed(Qt::MouseButtons buttons);
                 void released(Qt::MouseButtons buttons);
                 void doubleClicked(Qt::MouseButtons buttons);
             private:
                 void updateGeometry();
                 QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart);
                 QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart);
             private:
                 PieSliceData m_data;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 QPainterPath m_labelArmPath;
                 QRectF m_labelTextRect;
                 bool m_hovered;
                 QGraphicsTextItem *m_labelItem;
-                QPointF m_lastMousePos;
                 bool m_mousePressed;
                 friend class PieSliceAnimation;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // PIESLICEITEM_H

src/charts/piechart/qpieseries.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QPieSeries>
             #include <private/qpieseries_p.h>
             #include <QtCharts/QPieSlice>
             #include <private/qpieslice_p.h>
             #include <private/pieslicedata_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/pieanimation_p.h>
             #include <private/charthelpers_p.h>
             #include <QtCharts/QPieLegendMarker>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \inmodule Qt Charts
                 \brief Pie series API for Qt Charts.
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0.
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} or \l {DonutChart Example} {donut chart example} to learn how to use QPieSeries.
                 \table 100%
                 \row
                 \li \image examples_piechart.png
                 \li \image examples_donutchart.png
                 \endtable
             */
             /*!
                 \qmltype PieSeries
                 \instantiates QPieSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The PieSeries type is used for making pie charts.
                 The following QML shows how to create a simple pie chart.
                 \snippet qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image examples_qmlchart1.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the absolute left.
                 \li 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \qmlproperty real PieSeries::horizontalPosition
                 Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the absolute left.
                 \li 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the absolute top.
                 \li 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \qmlproperty real PieSeries::verticalPosition
                 Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the absolute top.
                 \li 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (pie not drawn).
                 \li 1.0 is the maximum size that can fit the chart.
                 \endlist
                 When setting this property the holeSize property is adjusted if necessary, to ensure that the hole size is not greater than the outer size.
                 Default value is 0.7.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (pie not drawn).
                 \li 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::holeSize
                 \brief Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \li 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.0.
             */
             /*!
                 \qmlproperty real PieSeries::holeSize
                 Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \li 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 When setting this property the size property is adjusted if necessary, to ensure that the inner size is not greater than the outer size.
                 Default value is 0.0.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \qmlsignal PieSeries::onCountChanged()
                 Emitted when the slice count has changed.
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \qmlsignal PieSeries::onSumChanged()
                 Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                 change value of a slice.
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
-                \fn void QPieSeries::clicked(QPieSlice* slice)
+                \fn void QPieSeries::clicked(QPieSlice *slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
               \qmlsignal PieSeries::onClicked(PieSlice slice)
               This signal is emitted when a \a slice has been clicked.
             */
             /*!
-                \fn void QPieSeries::pressed(QPieSlice* slice)
+                \fn void QPieSeries::pressed(QPieSlice *slice)
                 This signal is emitted when a \a slice has been pressed.
                 \sa QPieSlice::pressed()
             */
             /*!
                 \qmlsignal PieSeries::onPressed(PieSlice slice)
                 This signal is emitted when a \a slice has been pressed.
             */
             /*!
-                \fn void QPieSeries::released(QPieSlice* slice)
+                \fn void QPieSeries::released(QPieSlice *slice)
                 This signal is emitted when a \a slice has been released.
                 \sa QPieSlice::released()
             */
             /*!
                 \qmlsignal PieSeries::onReleased(PieSlice slice)
                 This signal is emitted when a \a slice has been released.
             */
             /*!
-                \fn void QPieSeries::doubleClicked(QPieSlice* slice)
+                \fn void QPieSeries::doubleClicked(QPieSlice *slice)
                 This signal is emitted when a \a slice has been doubleClicked.
                 \sa QPieSlice::doubleClicked()
             */
             /*!
                 \qmlsignal PieSeries::onDoubleClicked(PieSlice slice)
                 This signal is emitted when a \a slice has been doubleClicked.
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                 over the slice and false when hover has moved away from the slice.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successful, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent)
                 : QAbstractSeries(*new QPieSeriesPrivate(this), parent)
             {
                 Q_D(QPieSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
                 clear();
             }
             /*!
                 Returns QAbstractSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice *slice)
             {
                 return append(QList<QPieSlice *>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successful.
             */
             bool QPieSeries::append(QList<QPieSlice *> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice *s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                     if (!isValidValue(s->value()))
                         return false;
                 }
                 foreach (QPieSlice *s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach(QPieSlice * s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                     connect(s, SIGNAL(pressed()), d, SLOT(slicePressed()));
                     connect(s, SIGNAL(released()), d, SLOT(sliceReleased()));
                     connect(s, SIGNAL(doubleClicked()), d, SLOT(sliceDoubleClicked()));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries &QPieSeries::operator << (QPieSlice *slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
                 Returns NULL if value is NaN, Inf or -Inf and no slice is added to the series.
             */
             QPieSlice *QPieSeries::append(QString label, qreal value)
             {
                 if (isValidValue(value)) {
                     QPieSlice *slice = new QPieSlice(label, value);
                     append(slice);
                     return slice;
                 } else {
                     return 0;
                 }
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successful.
             */
             bool QPieSeries::insert(int index, QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 if (!isValidValue(slice->value()))
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 connect(slice, SIGNAL(pressed()), d, SLOT(slicePressed()));
                 connect(slice, SIGNAL(released()), d, SLOT(sliceReleased()));
                 connect(slice, SIGNAL(doubleClicked()), d, SLOT(sliceDoubleClicked()));
                 emit added(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successful.
             */
             bool QPieSeries::remove(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Takes a single \a slice from the series. Does not destroy the slice object.
                 \note The series remains as the slice's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QPieSeries::take(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 QPieSlicePrivate::fromSlice(slice)->m_series = 0;
                 slice->disconnect(d);
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice *> slices = d->m_slices;
                 foreach (QPieSlice *s, d->m_slices)
                     d->m_slices.removeOne(s);
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
                 foreach (QPieSlice *s, slices)
                     delete s;
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice *> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setHoleSize(qreal holeSize)
             {
                 Q_D(QPieSeries);
                 holeSize = qBound((qreal)0.0, holeSize, (qreal)1.0);
                 d->setSizes(holeSize, qMax(d->m_pieRelativeSize, holeSize));
             }
             qreal QPieSeries::holeSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_holeRelativeSize;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyCompare(d->m_pieRelativeHorPos, relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyCompare(d->m_pieRelativeVerPos, relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 relativeSize = qBound((qreal)0.0, relativeSize, (qreal)1.0);
                 d->setSizes(qMin(d->m_holeRelativeSize, relativeSize), relativeSize);
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyCompare(d->m_pieStartAngle, angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyCompare(d->m_pieEndAngle, angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Sets the all the slice labels \a position
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label position is LabelOutside
                 \sa QPieSlice::labelPosition(), QPieSlice::setLabelPosition()
             */
             void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelPosition(position);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_holeRelativeSize(0.0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice *s, m_slices)
                     sum += s->value();
                 if (!qFuzzyCompare(m_sum, sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyCompare(m_sum, 0))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice *> changed;
                 foreach (QPieSlice *s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize)
             {
                 bool changed = false;
                 if (!qFuzzyCompare(m_holeRelativeSize, innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
                 if (!qFuzzyCompare(m_pieRelativeSize, outerSize)) {
                     m_pieRelativeSize = outerSize;
                     changed = true;
                 }
                 if (changed)
                     emit pieSizeChanged();
             }
             QPieSeriesPrivate *QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 if (!m_slices.isEmpty()) {
                     Q_ASSERT(m_slices.contains(slice));
                     Q_Q(QPieSeries);
                     emit q->hovered(slice, state);
                 }
             }
             void QPieSeriesPrivate::slicePressed()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->pressed(slice);
             }
             void QPieSeriesPrivate::sliceReleased()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->released(slice);
             }
             void QPieSeriesPrivate::sliceDoubleClicked()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->doubleClicked(slice);
             }
             void QPieSeriesPrivate::initializeDomain()
             {
                 // does not apply to pie
             }
             void QPieSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPieSeries);
                 PieChartItem *pie = new PieChartItem(q,parent);
                 m_item.reset(pie);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QPieSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
             {
                 PieChartItem *item = static_cast<PieChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new PieAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QPieSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     QPieLegendMarker* marker = new QPieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             QAbstractAxis* QPieSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QPieSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 //Q_Q(QPieSeries);
                 //const QList<QColor>& colors = theme->seriesColors();
                 const QList<QGradient>& gradients = theme->seriesGradients();
                 for (int i(0); i < m_slices.count(); i++) {
                     QColor penColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal)(i + 1) / (qreal) m_slices.count();
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), pos);
                     QPieSlice *s = m_slices.at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (forced || d->m_data.m_slicePen.isThemed())
                         d->setPen(penColor, true);
                     if (forced || d->m_data.m_sliceBrush.isThemed())
                         d->setBrush(brushColor, true);
                     if (forced || d->m_data.m_labelBrush.isThemed())
                         d->setLabelBrush(theme->labelBrush().color(), true);
                     if (forced || d->m_data.m_labelFont.isThemed())
                         d->setLabelFont(theme->labelFont(), true);
                 }
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/scatterchart/scatterchartitem_p.h +2 -7

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef SCATTERCHARTITEM_H
             #define SCATTERCHARTITEM_H
             #include <QtCharts/QChartGlobal>
             #include <private/xychart_p.h>
             #include <QtWidgets/QGraphicsEllipseItem>
             #include <QtGui/QPen>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             class QScatterSeries;
             class ScatterChartItem : public XYChart
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
                 explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *item = 0);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen &pen);
                 void setBrush(const QBrush &brush);
                 void markerSelected(QGraphicsItem *item);
                 void markerHovered(QGraphicsItem *item, bool state);
                 void markerPressed(QGraphicsItem *item);
                 void markerReleased(QGraphicsItem *item);
                 void markerDoubleClicked(QGraphicsItem *item);
-                void setLastMousePosition(const QPointF pos) {m_lastMousePos = pos;}
-                QPointF lastMousePosition() const {return m_lastMousePos;}
                 void setMousePressed(bool pressed = true) {m_mousePressed = pressed;}
                 bool mousePressed() {return m_mousePressed;}
             public Q_SLOTS:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void updateGeometry();
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 bool m_visible;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
                 QMap<QGraphicsItem *, QPointF> m_markerMap;
                 bool m_pointLabelsVisible;
                 QString m_pointLabelsFormat;
                 QFont m_pointLabelsFont;
                 QColor m_pointLabelsColor;
-                QPointF m_lastMousePos;
                 bool m_mousePressed;
             };
             class CircleMarker: public QGraphicsEllipseItem
             {
             public:
                 CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
                     : QGraphicsEllipseItem(x, y, w, h, parent),
                       m_parent(parent)
                 {
                     setAcceptHoverEvents(true);
                     setFlag(QGraphicsItem::ItemIsSelectable);
                 }
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsEllipseItem::mousePressEvent(event);
                     m_parent->markerPressed(this);
-                    m_parent->setLastMousePosition(event->pos());
                     m_parent->setMousePressed();
                 }
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event)
                 {
                     QGraphicsEllipseItem::hoverEnterEvent(event);
                     m_parent->markerHovered(this, true);
                 }
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
                 {
                     QGraphicsEllipseItem::hoverLeaveEvent(event);
                     m_parent->markerHovered(this, false);
                 }
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsEllipseItem::mouseReleaseEvent(event);
                     m_parent->markerReleased(this);
-                    if (m_parent->lastMousePosition() == event->pos() && m_parent->mousePressed())
+                    if (m_parent->mousePressed())
                         m_parent->markerSelected(this);
                     m_parent->setMousePressed(false);
                 }
                 void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsEllipseItem::mouseDoubleClickEvent(event);
                     m_parent->markerDoubleClicked(this);
                 }
             private:
                 ScatterChartItem *m_parent;
             };
             class RectangleMarker: public QGraphicsRectItem
             {
             public:
                 RectangleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
                     : QGraphicsRectItem(x, y, w, h, parent),
                       m_parent(parent)
                 {
                     setAcceptHoverEvents(true);
                     setFlag(QGraphicsItem::ItemIsSelectable);
                 }
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsRectItem::mousePressEvent(event);
                     m_parent->markerPressed(this);
-                    m_parent->setLastMousePosition(event->pos());
                     m_parent->setMousePressed();
                 }
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event)
                 {
                     QGraphicsRectItem::hoverEnterEvent(event);
                     m_parent->markerHovered(this, true);
                 }
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
                 {
                     QGraphicsRectItem::hoverLeaveEvent(event);
                     m_parent->markerHovered(this, false);
                 }
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsRectItem::mouseReleaseEvent(event);
                     m_parent->markerReleased(this);
-                    if (m_parent->lastMousePosition() == event->pos() && m_parent->mousePressed())
+                    if (m_parent->mousePressed())
                         m_parent->markerSelected(this);
                     m_parent->setMousePressed(false);
                 }
                 void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
                 {
                     QGraphicsRectItem::mouseDoubleClickEvent(event);
                     m_parent->markerDoubleClicked(this);
                 }
             private:
                 ScatterChartItem *m_parent;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/charts/splinechart/splinechartitem.cpp +4 -4

             /****************************************************************************
              **
              ** Copyright (C) 2014 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, 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 Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/splinechartitem_p.h>
             #include <private/qsplineseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/splineanimation_p.h>
             #include <private/polardomain_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_animation(0),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 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()));
                 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()));
                 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->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->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->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;
                 }
                 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());
                 // Only zoom in if the bounding rects of the path fit inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 QPainterPath checkShapePath = stroker.createStroke(fullPath);
                 if (checkShapePath.boundingRect().height() <= INT_MAX
                         && checkShapePath.boundingRect().width() <= INT_MAX
                         && splinePath.boundingRect().height() <= INT_MAX
                         && splinePath.boundingRect().width() <= INT_MAX) {
                     m_path = splinePath;
                     prepareGeometryChange();
                     m_fullPath = checkShapePath;
                     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());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 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());
                 }
                 if (m_pointLabelsVisible)
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points, m_linePen.width() / 2);
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 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);
             }
             void SplineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit XYChart::released(domain()->calculateDomainPoint(event->pos()));
+                emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
-                if (m_lastMousePos == event->pos() && m_mousePressed)
+                if (m_mousePressed)
-                    emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
+                    emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void SplineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit XYChart::doubleClicked(domain()->calculateDomainPoint(event->pos()));
+                emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/xychart/qxyseries.cpp +19 -6

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QXYSeries>
             #include <private/qxyseries_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QValueAxis>
             #include <private/xychart_p.h>
             #include <QtCharts/QXYLegendMarker>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             #include <QtGui/QPainter>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \inmodule Qt Charts
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmltype XYSeries
                 \instantiates QXYSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The XYSeries type is a base type for line, spline and scatter series.
                 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.
             */
             /*!
                 \property QXYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QXYSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa QXYSeries::pointLabelsVisible, QXYSeries::pointLabelsFont, QXYSeries::pointLabelsColor
             */
             /*!
                 \qmlproperty string XYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa QXYSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QXYSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QXYSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty bool XYSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QXYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QXYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
-                \brief Signal is emitted when user clicks the \a point on chart.
+                \brief Signal is emitted when user clicks the \a point on chart. The \a point is the point
+                where the press was triggered.
+                \sa pressed, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
-                Signal is emitted when user clicks the \a point on chart. For example:
+                Signal is emitted when user clicks the \a point on chart. The \a point is the point where the
+                press was triggered. 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
+                \sa onPressed, onReleased, onDoubleClicked
             */
             /*!
                 \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::pressed(const QPointF& point)
                 \brief Signal is emitted when user presses the \a point on chart.
+                \sa clicked, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onPressed(QPointF point)
                 Signal is emitted when user presses the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onPressed: console.log("onPressed: " + point.x + ", " + point.y);
                 }
                 \endcode
+                \sa onClicked, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::released(const QPointF& point)
-                \brief Signal is emitted when user releases the \a point on chart.
+                \brief Signal is emitted when user releases a press that was triggered on a \a point on chart.
+                \sa pressed, clicked, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onReleased(QPointF point)
-                Signal is emitted when user releases the \a point on chart. For example:
+                Signal is emitted when user releases a press that was triggered on a \a point on chart.
+                For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onReleased: console.log("onReleased: " + point.x + ", " + point.y);
                 }
                 \endcode
+                \sa onPressed, onClicked, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::doubleClicked(const QPointF& point)
-                \brief Signal is emitted when user doubleclicks the \a point on chart.
+                \brief Signal is emitted when user doubleclicks the \a point on chart. The \a point is the
+                point where the first press was triggered.
+                \sa pressed, released, clicked
             */
             /*!
                 \qmlsignal XYSeries::onDoubleClicked(QPointF point)
-                Signal is emitted when user doubleclicks the \a point on chart. For example:
+                Signal is emitted when user doubleclicks the \a point on chart. The \a point is the point where
+                the first press was triggered. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onDoubleClicked: console.log("onDoubleClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
+                \sa onPressed, onReleased, onClicked
             */
             /*!
                 \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 other 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 QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series.
              */
             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.
              */
             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;
                 replace(index, newPoint);
             }
             /*!
               Replaces the point at \a index with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, qreal newX, qreal newY)
             {
                 replace(index, QPointF(newX, newY));
             }
             /*!
               Replaces the point at \a index with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points.
               \note This is much 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 the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 remove(index);
             }
             /*!
               Removes the point at \a index from the series.
             */
             void QXYSeries::remove(int index)
             {
                 Q_D(QXYSeries);
                 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::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);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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;
             }
             void QXYSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QXYSeries::pointLabelsFormat() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFormat;
             }
             void QXYSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QXYSeries::pointLabelsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsVisible;
             }
             void QXYSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QXYSeries::pointLabelsFont() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFont;
             }
             void QXYSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QXYSeries::pointLabelsColor() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             /*!
                 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_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color())
             {
             }
             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 new QValueAxis;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new XYAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             void QXYSeriesPrivate::drawSeriesPointLabels(QPainter *painter, const QVector<QPointF> &points,
                                                          const int offset)
             {
                 static const QString xPointTag(QLatin1String("@xPoint"));
                 static const QString yPointTag(QLatin1String("@yPoint"));
                 const int labelOffset = offset + 2;
                 painter->setFont(m_pointLabelsFont);
                 painter->setPen(QPen(m_pointLabelsColor));
                 QFontMetrics fm(painter->font());
                 for (int i(0); i < m_points.size(); i++) {
                     QString pointLabel = m_pointLabelsFormat;
                     pointLabel.replace(xPointTag, presenter()->numberToString(m_points.at(i).x()));
                     pointLabel.replace(yPointTag, presenter()->numberToString(m_points.at(i).y()));
                     // Position text in relation to the point
                     int pointLabelWidth = fm.width(pointLabel);
                     QPointF position(points.at(i));
                     position.setX(position.x() - pointLabelWidth / 2);
                     position.setY(position.y() - labelOffset);
                     painter->drawText(position, pointLabel);
                 }
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

tests/auto/qlineseries/tst_qlineseries.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QLineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
             class tst_QLineSeries : public tst_QXYSeries
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qlineseries_data();
                 void qlineseries();
                 void pressedSignal();
                 void releasedSignal();
                 void doubleClickedSignal();
             protected:
                 void pointsVisible_data();
             };
             void tst_QLineSeries::initTestCase()
             {
             }
             void tst_QLineSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QLineSeries::init()
             {
                 tst_QXYSeries::init();
                 m_series = new QLineSeries();
             }
             void tst_QLineSeries::cleanup()
             {
                 delete m_series;
                 m_series=0;
                 tst_QXYSeries::cleanup();
             }
             void tst_QLineSeries::qlineseries_data()
             {
             }
             void tst_QLineSeries::qlineseries()
             {
                 QLineSeries series;
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 QCOMPARE(series.pointLabelsVisible(), false);
                 QCOMPARE(series.pointLabelsFormat(), QLatin1String("@xPoint, @yPoint"));
                 series.append(QList<QPointF>());
                 series.append(0.0,0.0);
                 series.append(QPointF());
                 series.remove(0.0,0.0);
                 series.remove(QPointF());
                 series.clear();
                 series.replace(QPointF(),QPointF());
                 series.replace(0,0,0,0);
                 series.setBrush(QBrush());
                 series.setPen(QPen());
                 series.setPointsVisible(false);
                 series.setPointLabelsVisible(false);
                 series.setPointLabelsFormat(QString());
                 m_chart->addSeries(&series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QLineSeries::pressedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 1));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(pressed(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             void tst_QLineSeries::releasedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 20));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(released(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             void tst_QLineSeries::doubleClickedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 20));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(doubleClicked(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
+                // mouseClick needed first to save the position
+                QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             QTEST_MAIN(tst_QLineSeries)
             #include "tst_qlineseries.moc"

tests/auto/qsplineseries/tst_qsplineseries.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QSplineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
             class tst_QSplineSeries : public tst_QXYSeries
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qsplineseries_data();
                 void qsplineseries();
                 void pressedSignal();
                 void releasedSignal();
                 void doubleClickedSignal();
             protected:
                 void pointsVisible_data();
             };
             void tst_QSplineSeries::initTestCase()
             {
             }
             void tst_QSplineSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QSplineSeries::init()
             {
                 tst_QXYSeries::init();
                 m_series = new QSplineSeries();
             }
             void tst_QSplineSeries::cleanup()
             {
                 delete m_series;
                 tst_QXYSeries::cleanup();
             }
             void tst_QSplineSeries::qsplineseries_data()
             {
             }
             void tst_QSplineSeries::qsplineseries()
             {
                 QSplineSeries series;
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 series.append(QList<QPointF>());
                 series.append(0.0,0.0);
                 series.append(QPointF());
                 series.remove(0.0,0.0);
                 series.remove(QPointF());
                 series.clear();
                 series.replace(QPointF(),QPointF());
                 series.replace(0,0,0,0);
                 series.setBrush(QBrush());
                 series.setPen(QPen());
                 series.setPointsVisible(false);
                 m_chart->addSeries(&series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QSplineSeries::pressedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 1));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(pressed(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             void tst_QSplineSeries::releasedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 20));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(released(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             void tst_QSplineSeries::doubleClickedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 20));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(doubleClicked(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
+                // mouseClick needed first to save the position
+                QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             QTEST_MAIN(tst_QSplineSeries)
             #include "tst_qsplineseries.moc"

tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, 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 Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtCharts 2.0
             ChartView {
                 title: "scatter series"
                 property variant series: scatterSeries
                 animationOptions: ChartView.SeriesAnimations
                 ScatterSeries {
                     id: scatterSeries
                     name: "scatter 1"
                     XYPoint { x: 1.5; y: 1.5 }
                     XYPoint { x: 1.5; y: 1.6 }
                     XYPoint { x: 1.57; y: 1.55 }
                     XYPoint { x: 1.8; y: 1.8 }
                     XYPoint { x: 1.9; y: 1.6 }
                     XYPoint { x: 2.1; y: 1.3 }
                     XYPoint { x: 2.5; y: 2.1 }
                     pointLabelsFormat: "@xPoint, @yPoint";
                     onNameChanged:              console.log("scatterSeries.onNameChanged: " + name);
                     onVisibleChanged:           console.log("scatterSeries.onVisibleChanged: " + visible);
                     onOpacityChanged:           console.log(name + ".onOpacityChanged: " + opacity);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onHovered:                  console.log(name + ".onHovered: " + point.x + ", " + point.y);
                     onPointReplaced:            console.log("scatterSeries.onPointReplaced: " + index);
                     onPointRemoved:             console.log("scatterSeries.onPointRemoved: " + index);
                     onPointAdded:               console.log("scatterSeries.onPointAdded: " + series.at(index).x + ", " + series.at(index).y);
                     onColorChanged:             console.log("scatterSeries.onColorChanged: " + color);
                     onBorderColorChanged:       console.log("scatterSeries.onBorderColorChanged: " + borderColor);
                     onBorderWidthChanged:       console.log("scatterSeries.onBorderChanged: " + borderWidth);
                     onCountChanged:             console.log("scatterSeries.onCountChanged: " + count);
-                    onPointLabelsVisibilityChanged:  console.log("lineSeries.onPointLabelsVisibilityChanged: "
+                    onPointLabelsVisibilityChanged:  console.log("scatterSeries.onPointLabelsVisibilityChanged: "
                                                                  + visible);
-                    onPointLabelsFormatChanged:      console.log("lineSeries.onPointLabelsFormatChanged: "
+                    onPointLabelsFormatChanged:      console.log("scatterSeries.onPointLabelsFormatChanged: "
                                                                  + format);
-                    onPointLabelsFontChanged:        console.log("lineSeries.onPointLabelsFontChanged: "
+                    onPointLabelsFontChanged:        console.log("scatterSeries.onPointLabelsFontChanged: "
                                                                  + font.family);
-                    onPointLabelsColorChanged:       console.log("lineSeries.onPointLabelsColorChanged: "
+                    onPointLabelsColorChanged:       console.log("scatterSeries.onPointLabelsColorChanged: "
                                                                  + color);
                     onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
                     onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
                     onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
                 }
                 ScatterSeries {
                     name: "scatter2"
                     XYPoint { x: 2.0; y: 2.0 }
                     XYPoint { x: 2.0; y: 2.1 }
                     XYPoint { x: 2.07; y: 2.05 }
                     XYPoint { x: 2.2; y: 2.9 }
                     XYPoint { x: 2.4; y: 2.7 }
                     XYPoint { x: 2.67; y: 2.65 }
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onHovered:                  console.log(name + ".onHovered: " + point.x + ", " + point.y);
                     onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
                     onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
                     onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
                 }
             }

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