diff --git a/examples/charts/chartinteractions/main.cpp b/examples/charts/chartinteractions/main.cpp index b4c05fa..f365af8 100644 --- a/examples/charts/chartinteractions/main.cpp +++ b/examples/charts/chartinteractions/main.cpp @@ -60,7 +60,7 @@ int main(int argc, char *argv[]) chart->setAxisY(axisY, series); axisY->setRange(0, 13); - QObject::connect(series, SIGNAL(clicked(QPointF)), chart, SLOT(clickPoint(QPointF))); + QObject::connect(series, SIGNAL(pressed(QPointF)), chart, SLOT(clickPoint(QPointF))); ChartView *chartView = new ChartView(chart); chartView->setRenderHint(QPainter::Antialiasing); diff --git a/src/charts/areachart/areachartitem.cpp b/src/charts/areachart/areachartitem.cpp index a4ccedd..30c949b 100644 --- a/src/charts/areachart/areachartitem.cpp +++ b/src/charts/areachart/areachartitem.cpp @@ -40,9 +40,11 @@ AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item) m_pointLabelsVisible(false), m_pointLabelsFormat(areaSeries->pointLabelsFormat()), m_pointLabelsFont(areaSeries->pointLabelsFont()), - m_pointLabelsColor(areaSeries->pointLabelsColor()) + 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()); @@ -54,6 +56,10 @@ AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item) 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)), @@ -239,7 +245,9 @@ void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { - emit clicked(m_upper->domain()->calculateDomainPoint(event->pos())); + emit pressed(m_upper->domain()->calculateDomainPoint(event->pos())); + m_lastMousePos = event->pos(); + m_mousePressed = true; ChartItem::mousePressEvent(event); } @@ -257,6 +265,21 @@ void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) // QGraphicsItem::hoverEnterEvent(event); } +void AreaChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) +{ + emit released(m_upper->domain()->calculateDomainPoint(event->pos())); + if (m_lastMousePos == event->pos() && m_mousePressed) + emit clicked(m_upper->domain()->calculateDomainPoint(event->pos())); + m_mousePressed = false; + ChartItem::mouseReleaseEvent(event); +} + +void AreaChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) +{ + emit doubleClicked(m_upper->domain()->calculateDomainPoint(event->pos())); + ChartItem::mouseDoubleClickEvent(event); +} + #include "moc_areachartitem_p.cpp" QT_CHARTS_END_NAMESPACE diff --git a/src/charts/areachart/areachartitem_p.h b/src/charts/areachart/areachartitem_p.h index c0b86ee..e4aaf6c 100644 --- a/src/charts/areachart/areachartitem_p.h +++ b/src/charts/areachart/areachartitem_p.h @@ -63,10 +63,15 @@ protected: void mousePressEvent(QGraphicsSceneMouseEvent *event); void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void hoverLeaveEvent(QGraphicsSceneHoverEvent *event); + void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event); Q_SIGNALS: void clicked(const QPointF &point); void hovered(const QPointF &point, bool state); + void pressed(const QPointF &point); + void released(const QPointF &point); + void doubleClicked(const QPointF &point); public Q_SLOTS: void handleUpdated(); @@ -88,6 +93,9 @@ private: QFont m_pointLabelsFont; QColor m_pointLabelsColor; + QPointF m_lastMousePos; + bool m_mousePressed; + }; class AreaBoundItem : public LineChartItem diff --git a/src/charts/areachart/qareaseries.cpp b/src/charts/areachart/qareaseries.cpp index 9060294..9d4cef4 100644 --- a/src/charts/areachart/qareaseries.cpp +++ b/src/charts/areachart/qareaseries.cpp @@ -168,6 +168,33 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \fn void QAreaSeries::pressed(const QPointF& point) + \brief Signal is emitted when user presses the \a point on area chart. +*/ +/*! + \qmlsignal AreaSeries::onPressed(QPointF point) + Signal is emitted when user presses the \a point on area chart. +*/ + +/*! + \fn void QAreaSeries::released(const QPointF& point) + \brief Signal is emitted when user releases the \a point on area chart. +*/ +/*! + \qmlsignal AreaSeries::onReleased(QPointF point) + Signal is emitted when user releases the \a point on area chart. +*/ + +/*! + \fn void QAreaSeries::doubleClicked(const QPointF& point) + \brief Signal is emitted when user doubleclicks the \a point on area chart. +*/ +/*! + \qmlsignal AreaSeries::onDoubleClicked(QPointF point) + Signal is emitted when user doubleclicks the \a point on area chart. +*/ + +/*! \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. diff --git a/src/charts/areachart/qareaseries.h b/src/charts/areachart/qareaseries.h index 2e4c89c..dab49cf 100644 --- a/src/charts/areachart/qareaseries.h +++ b/src/charts/areachart/qareaseries.h @@ -85,6 +85,9 @@ public: Q_SIGNALS: void clicked(const QPointF &point); void hovered(const QPointF &point, bool state); + void pressed(const QPointF &point); + void released(const QPointF &point); + void doubleClicked(const QPointF &point); void selected(); void colorChanged(QColor color); void borderColorChanged(QColor color); diff --git a/src/charts/barchart/abstractbarchartitem.cpp b/src/charts/barchart/abstractbarchartitem.cpp index 1d32d9f..c2f4c27 100644 --- a/src/charts/barchart/abstractbarchartitem.cpp +++ b/src/charts/barchart/abstractbarchartitem.cpp @@ -42,6 +42,7 @@ AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphics { setFlag(ItemClipsChildrenToShape); + setFlag(QGraphicsItem::ItemIsSelectable); connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged())); connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars())); connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool))); @@ -163,8 +164,16 @@ void AbstractBarChartItem::handleDataStructureChanged() m_bars.append(bar); connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*))); connect(bar, SIGNAL(hovered(bool, int, QBarSet*)), m_series, SIGNAL(hovered(bool, int, QBarSet*))); + connect(bar, SIGNAL(pressed(int, QBarSet*)), m_series, SIGNAL(pressed(int, QBarSet*))); + connect(bar, SIGNAL(released(int, QBarSet*)), + m_series, SIGNAL(released(int, QBarSet*))); + connect(bar, SIGNAL(doubleClicked(int, QBarSet*)), + m_series, SIGNAL(doubleClicked(int, QBarSet*))); connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int))); connect(bar, SIGNAL(hovered(bool, int, QBarSet*)), set, SIGNAL(hovered(bool, int))); + connect(bar, SIGNAL(pressed(int, QBarSet*)), set, SIGNAL(pressed(int))); + connect(bar, SIGNAL(released(int, QBarSet*)), set, SIGNAL(released(int))); + connect(bar, SIGNAL(doubleClicked(int, QBarSet*)), set, SIGNAL(doubleClicked(int))); // m_layout.append(QRectF(0, 0, 1, 1)); // Labels diff --git a/src/charts/barchart/bar.cpp b/src/charts/barchart/bar.cpp index 400fd58..6338dbe 100644 --- a/src/charts/barchart/bar.cpp +++ b/src/charts/barchart/bar.cpp @@ -21,16 +21,20 @@ #include #include #include +#include +#include QT_CHARTS_BEGIN_NAMESPACE Bar::Bar(QBarSet *barset, int index, QGraphicsItem *parent) : QGraphicsRectItem(parent), m_index(index), m_barset(barset), - m_hovering(false) + m_hovering(false), + m_mousePressed(false) { setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton); setAcceptHoverEvents(true); + setFlag(QGraphicsItem::ItemIsSelectable); } Bar::~Bar() @@ -42,8 +46,9 @@ Bar::~Bar() void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event) { - Q_UNUSED(event) - emit clicked(m_index, m_barset); + emit pressed(m_index, m_barset); + m_lastMousePos = event->pos(); + m_mousePressed = true; QGraphicsItem::mousePressEvent(event); } @@ -62,6 +67,29 @@ void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) 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) + 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 diff --git a/src/charts/barchart/bar_p.h b/src/charts/barchart/bar_p.h index 4f8b010..5f355b0 100644 --- a/src/charts/barchart/bar_p.h +++ b/src/charts/barchart/bar_p.h @@ -49,15 +49,25 @@ 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 diff --git a/src/charts/barchart/qabstractbarseries.cpp b/src/charts/barchart/qabstractbarseries.cpp index e049ee5..7f785d2 100644 --- a/src/charts/barchart/qabstractbarseries.cpp +++ b/src/charts/barchart/qabstractbarseries.cpp @@ -211,6 +211,39 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \fn void QAbstractBarSeries::pressed(int index, QBarSet *barset) + The signal is emitted if the user presses with a mouse on top of QBarSet \a barset. + Pressed bar inside set is indexed by \a index +*/ +/*! + \qmlsignal AbstractBarSeries::onPressed(int index, BarSet barset) + The signal is emitted if the user presses with a mouse on top of BarSet. + Pressed bar inside set is indexed by \a index +*/ + +/*! + \fn void QAbstractBarSeries::released(int index, QBarSet *barset) + The signal is emitted if the user releases with a mouse on top of QBarSet \a barset. + Released bar inside set is indexed by \a index +*/ +/*! + \qmlsignal AbstractBarSeries::onReleased(int index, BarSet barset) + The signal is emitted if the user releases with a mouse on top of BarSet. + Released bar inside set is indexed by \a index +*/ + +/*! + \fn void QAbstractBarSeries::doubleClicked(int index, QBarSet *barset) + The signal is emitted if the user doubleclicks with a mouse on top of QBarSet \a barset. + DoubleClicked bar inside set is indexed by \a index +*/ +/*! + \qmlsignal AbstractBarSeries::onDoubleClicked(int index, BarSet barset) + The signal is emitted if the user doubleclicks with a mouse on top of BarSet. + Doubleclicked bar inside set is indexed by \a index +*/ + +/*! \fn void QAbstractBarSeries::hovered(bool status, int index, QBarSet* barset) The signal is emitted if mouse is hovered on top of series. diff --git a/src/charts/barchart/qabstractbarseries.h b/src/charts/barchart/qabstractbarseries.h index 47a0447..9a92ec8 100644 --- a/src/charts/barchart/qabstractbarseries.h +++ b/src/charts/barchart/qabstractbarseries.h @@ -78,6 +78,9 @@ protected: 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); void countChanged(); void labelsVisibleChanged(); void labelsFormatChanged(const QString &format); diff --git a/src/charts/barchart/qabstractbarseries_p.h b/src/charts/barchart/qabstractbarseries_p.h index c4ef169..e3fb769 100644 --- a/src/charts/barchart/qabstractbarseries_p.h +++ b/src/charts/barchart/qabstractbarseries_p.h @@ -89,6 +89,9 @@ public: Q_SIGNALS: void clicked(int index, QBarSet *barset); + void pressed(int index, QBarSet *barset); + void released(int index, QBarSet *barset); + void doubleClicked(int index, QBarSet *barset); void updatedBars(); void updatedLayout(); void restructuredBars(); diff --git a/src/charts/barchart/qbarset.cpp b/src/charts/barchart/qbarset.cpp index 0555b62..ba1fbf1 100644 --- a/src/charts/barchart/qbarset.cpp +++ b/src/charts/barchart/qbarset.cpp @@ -134,6 +134,27 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \fn void QBarSet::pressed(int index) + + The signal is emitted if the user presses with a mouse on top of bar set. + Pressed bar inside set is indexed by \a index +*/ + +/*! + \fn void QBarSet::released(int index) + + The signal is emitted if the user releases with a mouse on top of bar set. + Released bar inside set is indexed by \a index +*/ + +/*! + \fn void QBarSet::doubleClicked(int index) + + The signal is emitted if the user doubleclicks with a mouse on top of bar set. + Doubleclicked bar inside set is indexed by \a index +*/ + +/*! \fn void QBarSet::hovered(bool status, int index) The signal is emitted if mouse is hovered on top of bar set. diff --git a/src/charts/barchart/qbarset.h b/src/charts/barchart/qbarset.h index 2faafbe..8e1f307 100644 --- a/src/charts/barchart/qbarset.h +++ b/src/charts/barchart/qbarset.h @@ -85,6 +85,9 @@ public: Q_SIGNALS: void clicked(int index); void hovered(bool status, int index); + void pressed(int index); + void released(int index); + void doubleClicked(int index); void penChanged(); void brushChanged(); void labelChanged(); diff --git a/src/charts/boxplotchart/boxplotchartitem.cpp b/src/charts/boxplotchart/boxplotchartitem.cpp index 41baaaf..38efd8f 100644 --- a/src/charts/boxplotchart/boxplotchartitem.cpp +++ b/src/charts/boxplotchart/boxplotchartitem.cpp @@ -78,8 +78,15 @@ void BoxPlotChartItem::handleDataStructureChanged() m_boxTable.insert(set, box); connect(box, SIGNAL(clicked(QBoxSet *)), m_series, SIGNAL(clicked(QBoxSet *))); connect(box, SIGNAL(hovered(bool, QBoxSet *)), m_series, SIGNAL(hovered(bool, QBoxSet *))); + connect(box, SIGNAL(pressed(QBoxSet *)), m_series, SIGNAL(pressed(QBoxSet *))); + connect(box, SIGNAL(released(QBoxSet *)), m_series, SIGNAL(released(QBoxSet *))); + connect(box, SIGNAL(doubleClicked(QBoxSet *)), + m_series, SIGNAL(doubleClicked(QBoxSet *))); connect(box, SIGNAL(clicked(QBoxSet *)), set, SIGNAL(clicked())); connect(box, SIGNAL(hovered(bool, QBoxSet *)), set, SIGNAL(hovered(bool))); + connect(box, SIGNAL(pressed(QBoxSet *)), set, SIGNAL(pressed())); + connect(box, SIGNAL(released(QBoxSet *)), set, SIGNAL(released())); + connect(box, SIGNAL(doubleClicked(QBoxSet *)), set, SIGNAL(doubleClicked())); // Set the decorative issues for the newly created box // so that the brush and pen already defined for the set are kept. diff --git a/src/charts/boxplotchart/boxwhiskers.cpp b/src/charts/boxplotchart/boxwhiskers.cpp index db25ed2..9807d32 100644 --- a/src/charts/boxplotchart/boxwhiskers.cpp +++ b/src/charts/boxplotchart/boxwhiskers.cpp @@ -21,16 +21,19 @@ #include #include #include +#include QT_CHARTS_BEGIN_NAMESPACE BoxWhiskers::BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent) : QGraphicsObject(parent), m_boxSet(set), - m_domain(domain) + m_domain(domain), + m_mousePressed(false) { setAcceptHoverEvents(true); setAcceptedMouseButtons(Qt::MouseButtonMask); + setFlag(QGraphicsObject::ItemIsSelectable); } BoxWhiskers::~BoxWhiskers() @@ -39,8 +42,9 @@ BoxWhiskers::~BoxWhiskers() void BoxWhiskers::mousePressEvent(QGraphicsSceneMouseEvent *event) { - Q_UNUSED(event) - emit clicked(m_boxSet); + emit pressed(m_boxSet); + m_lastMousePos = event->pos(); + m_mousePressed = true; } void BoxWhiskers::hoverEnterEvent(QGraphicsSceneHoverEvent *event) @@ -55,6 +59,21 @@ void BoxWhiskers::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) emit hovered(false, m_boxSet); } +void BoxWhiskers::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) +{ + emit released(m_boxSet); + if (m_lastMousePos == event->pos() && 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; diff --git a/src/charts/boxplotchart/boxwhiskers_p.h b/src/charts/boxplotchart/boxwhiskers_p.h index 40bb678..30002f4 100644 --- a/src/charts/boxplotchart/boxwhiskers_p.h +++ b/src/charts/boxplotchart/boxwhiskers_p.h @@ -60,6 +60,8 @@ public: 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); @@ -72,6 +74,9 @@ protected: 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; @@ -95,6 +100,9 @@ private: qreal m_geometryMedian; qreal m_geometryLeft; qreal m_geometryRight; + + QPointF m_lastMousePos; + bool m_mousePressed; }; QT_CHARTS_END_NAMESPACE diff --git a/src/charts/boxplotchart/qboxplotseries.cpp b/src/charts/boxplotchart/qboxplotseries.cpp index e8b1c49..1360352 100644 --- a/src/charts/boxplotchart/qboxplotseries.cpp +++ b/src/charts/boxplotchart/qboxplotseries.cpp @@ -62,6 +62,18 @@ QT_CHARTS_BEGIN_NAMESPACE \brief Signal is emitted when the user clicks the \a boxset on the chart. */ /*! + \fn QBoxPlotSeries::pressed(QBoxSet *boxset) + \brief Signal is emitted when the user presses the \a boxset on the chart. +*/ +/*! + \fn QBoxPlotSeries::released(QBoxSet *boxset) + \brief Signal is emitted when the user releases the \a boxset on the chart. +*/ +/*! + \fn QBoxPlotSeries::doubleClicked(QBoxSet *boxset) + \brief Signal is emitted when the user doubleclicks the \a boxset on the chart. +*/ +/*! \fn QBoxPlotSeries::hovered(bool status, QBoxSet *boxset) \brief Signal is emitted when there is change in hover \a status over \a boxset. */ diff --git a/src/charts/boxplotchart/qboxplotseries.h b/src/charts/boxplotchart/qboxplotseries.h index bce67f6..de5b5fb 100644 --- a/src/charts/boxplotchart/qboxplotseries.h +++ b/src/charts/boxplotchart/qboxplotseries.h @@ -64,6 +64,9 @@ public: Q_SIGNALS: void clicked(QBoxSet *boxset); void hovered(bool status, QBoxSet *boxset); + void pressed(QBoxSet *boxset); + void released(QBoxSet *boxset); + void doubleClicked(QBoxSet *boxset); void countChanged(); void penChanged(); void brushChanged(); diff --git a/src/charts/boxplotchart/qboxplotseries_p.h b/src/charts/boxplotchart/qboxplotseries_p.h index 4655cff..7e8937e 100644 --- a/src/charts/boxplotchart/qboxplotseries_p.h +++ b/src/charts/boxplotchart/qboxplotseries_p.h @@ -74,6 +74,9 @@ private: Q_SIGNALS: void updated(); void clicked(int index, QBoxSet *barset); + void pressed(int index, QBoxSet *barset); + void released(int index, QBoxSet *barset); + void doubleClicked(int index, QBoxSet *barset); void updatedBoxes(); void updatedLayout(); void restructuredBoxes(); diff --git a/src/charts/boxplotchart/qboxset.cpp b/src/charts/boxplotchart/qboxset.cpp index 007dd3c..c542323 100644 --- a/src/charts/boxplotchart/qboxset.cpp +++ b/src/charts/boxplotchart/qboxset.cpp @@ -66,6 +66,22 @@ QT_CHARTS_BEGIN_NAMESPACE \fn void QBoxSet::clicked() The signal is emitted if the user clicks with a mouse on top of box-and-whisker item. */ + +/*! + \fn void QBoxSet::pressed() + The signal is emitted if the user presses with a mouse on top of box-and-whisker item. +*/ + +/*! + \fn void QBoxSet::released() + The signal is emitted if the user releases with a mouse on top of box-and-whisker item. +*/ + +/*! + \fn void QBoxSet::doubleClicked() + The signal is emitted if the user doubleclicks with a mouse on top of box-and-whisker item. +*/ + /*! \fn void QBoxSet::hovered(bool status) diff --git a/src/charts/boxplotchart/qboxset.h b/src/charts/boxplotchart/qboxset.h index d226861..39143f4 100644 --- a/src/charts/boxplotchart/qboxset.h +++ b/src/charts/boxplotchart/qboxset.h @@ -73,6 +73,9 @@ public: Q_SIGNALS: void clicked(); void hovered(bool status); + void pressed(); + void released(); + void doubleClicked(); void penChanged(); void brushChanged(); diff --git a/src/charts/linechart/linechartitem.cpp b/src/charts/linechart/linechartitem.cpp index 65582f3..4bf2d3b 100644 --- a/src/charts/linechart/linechartitem.cpp +++ b/src/charts/linechart/linechartitem.cpp @@ -40,9 +40,11 @@ LineChartItem::LineChartItem(QLineSeries *series, QGraphicsItem *item) m_pointLabelsVisible(false), m_pointLabelsFormat(series->pointLabelsFormat()), m_pointLabelsFont(series->pointLabelsFont()), - m_pointLabelsColor(series->pointLabelsColor()) + 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())); @@ -382,7 +384,9 @@ void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { - emit XYChart::clicked(domain()->calculateDomainPoint(event->pos())); + emit XYChart::pressed(domain()->calculateDomainPoint(event->pos())); + m_lastMousePos = event->pos(); + m_mousePressed = true; QGraphicsItem::mousePressEvent(event); } @@ -400,6 +404,21 @@ void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) QGraphicsItem::hoverEnterEvent(event); } +void LineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) +{ + emit XYChart::released(domain()->calculateDomainPoint(event->pos())); + if (m_lastMousePos == event->pos() && m_mousePressed) + emit XYChart::clicked(domain()->calculateDomainPoint(event->pos())); + m_mousePressed = false; + QGraphicsItem::mouseReleaseEvent(event); +} + +void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) +{ + emit XYChart::doubleClicked(domain()->calculateDomainPoint(event->pos())); + QGraphicsItem::mouseDoubleClickEvent(event); +} + #include "moc_linechartitem_p.cpp" QT_CHARTS_END_NAMESPACE diff --git a/src/charts/linechart/linechartitem_p.h b/src/charts/linechart/linechartitem_p.h index 337c4cc..bab5f8c 100644 --- a/src/charts/linechart/linechartitem_p.h +++ b/src/charts/linechart/linechartitem_p.h @@ -63,6 +63,8 @@ protected: void mousePressEvent(QGraphicsSceneMouseEvent *event); void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void hoverLeaveEvent(QGraphicsSceneHoverEvent *event); + void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event); void suppressPoints() { m_pointsVisible = false; } void forceChartType(QChart::ChartType chartType) { m_chartType = chartType; } @@ -84,6 +86,9 @@ private: QString m_pointLabelsFormat; QFont m_pointLabelsFont; QColor m_pointLabelsColor; + + QPointF m_lastMousePos; + bool m_mousePressed; }; QT_CHARTS_END_NAMESPACE diff --git a/src/charts/piechart/piechartitem.cpp b/src/charts/piechart/piechartitem.cpp index b81058a..4bc57f0 100644 --- a/src/charts/piechart/piechartitem.cpp +++ b/src/charts/piechart/piechartitem.cpp @@ -53,6 +53,8 @@ PieChartItem::PieChartItem(QPieSeries *series, QGraphicsItem* item) setZValue(ChartPresenter::PieSeriesZValue); // Note: will not create slice items until we have a proper rectangle to draw on. + + setFlag(QGraphicsItem::ItemIsSelectable); } PieChartItem::~PieChartItem() @@ -153,6 +155,9 @@ void PieChartItem::handleSlicesAdded(QList slices) connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked())); connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool))); + connect(sliceItem, SIGNAL(pressed(Qt::MouseButtons)), slice, SIGNAL(pressed())); + connect(sliceItem, SIGNAL(released(Qt::MouseButtons)), slice, SIGNAL(released())); + connect(sliceItem, SIGNAL(doubleClicked(Qt::MouseButtons)), slice, SIGNAL(doubleClicked())); PieSliceData sliceData = updateSliceGeometry(slice); if (m_animation) diff --git a/src/charts/piechart/piesliceitem.cpp b/src/charts/piechart/piesliceitem.cpp index 09c8a57..b42fb07 100644 --- a/src/charts/piechart/piesliceitem.cpp +++ b/src/charts/piechart/piesliceitem.cpp @@ -41,11 +41,13 @@ QPointF offset(qreal angle, qreal length) PieSliceItem::PieSliceItem(QGraphicsItem *parent) : QGraphicsObject(parent), - m_hovered(false) + 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); } @@ -108,7 +110,23 @@ void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/) void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { - emit clicked(event->buttons()); + 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) + 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) diff --git a/src/charts/piechart/piesliceitem_p.h b/src/charts/piechart/piesliceitem_p.h index b062d33..02295a4 100644 --- a/src/charts/piechart/piesliceitem_p.h +++ b/src/charts/piechart/piesliceitem_p.h @@ -61,6 +61,8 @@ public: 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); @@ -68,6 +70,9 @@ public: 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(); @@ -83,6 +88,9 @@ private: bool m_hovered; QGraphicsTextItem *m_labelItem; + QPointF m_lastMousePos; + bool m_mousePressed; + friend class PieSliceAnimation; }; diff --git a/src/charts/piechart/qpieseries.cpp b/src/charts/piechart/qpieseries.cpp index d536fe7..7339e6a 100644 --- a/src/charts/piechart/qpieseries.cpp +++ b/src/charts/piechart/qpieseries.cpp @@ -316,6 +316,36 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \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) + 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) + 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. @@ -424,6 +454,9 @@ bool QPieSeries::append(QList 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); @@ -490,6 +523,9 @@ bool QPieSeries::insert(int index, QPieSlice *slice) 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() << slice); emit countChanged(); @@ -854,6 +890,30 @@ void QPieSeriesPrivate::sliceHovered(bool state) } } +void QPieSeriesPrivate::slicePressed() +{ + QPieSlice *slice = qobject_cast(sender()); + Q_ASSERT(m_slices.contains(slice)); + Q_Q(QPieSeries); + emit q->pressed(slice); +} + +void QPieSeriesPrivate::sliceReleased() +{ + QPieSlice *slice = qobject_cast(sender()); + Q_ASSERT(m_slices.contains(slice)); + Q_Q(QPieSeries); + emit q->released(slice); +} + +void QPieSeriesPrivate::sliceDoubleClicked() +{ + QPieSlice *slice = qobject_cast(sender()); + Q_ASSERT(m_slices.contains(slice)); + Q_Q(QPieSeries); + emit q->doubleClicked(slice); +} + void QPieSeriesPrivate::initializeDomain() { // does not apply to pie diff --git a/src/charts/piechart/qpieseries.h b/src/charts/piechart/qpieseries.h index b8fd20d..c9deef6 100644 --- a/src/charts/piechart/qpieseries.h +++ b/src/charts/piechart/qpieseries.h @@ -89,6 +89,9 @@ Q_SIGNALS: void removed(QList slices); void clicked(QPieSlice *slice); void hovered(QPieSlice *slice, bool state); + void pressed(QPieSlice *slice); + void released(QPieSlice *slice); + void doubleClicked(QPieSlice *slice); void countChanged(); void sumChanged(); diff --git a/src/charts/piechart/qpieseries_p.h b/src/charts/piechart/qpieseries_p.h index bdc552d..0ae80bc 100644 --- a/src/charts/piechart/qpieseries_p.h +++ b/src/charts/piechart/qpieseries_p.h @@ -72,6 +72,9 @@ public Q_SLOTS: void sliceValueChanged(); void sliceClicked(); void sliceHovered(bool state); + void slicePressed(); + void sliceReleased(); + void sliceDoubleClicked(); private: QList m_slices; diff --git a/src/charts/piechart/qpieslice.cpp b/src/charts/piechart/qpieslice.cpp index 4a971e5..e3f5b4f 100644 --- a/src/charts/piechart/qpieslice.cpp +++ b/src/charts/piechart/qpieslice.cpp @@ -432,6 +432,36 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \fn void QPieSlice::pressed() + This signal is emitted when user has pressed the slice. + \sa QPieSeries::pressed() +*/ +/*! + \qmlsignal PieSlice::onPressed() + This signal is emitted when user has pressed the slice. +*/ + +/*! + \fn void QPieSlice::released() + This signal is emitted when user has released the slice. + \sa QPieSeries::released() +*/ +/*! + \qmlsignal PieSlice::onReleased() + This signal is emitted when user has released the slice. +*/ + +/*! + \fn void QPieSlice::doubleClicked() + This signal is emitted when user has doubleclicked the slice. + \sa QPieSeries::doubleClicked() +*/ +/*! + \qmlsignal PieSlice::onDoubleClicked() + This signal is emitted when user has doubleclicked the slice. +*/ + +/*! \fn void QPieSlice::hovered(bool state) This signal is emitted when user has hovered over or away from the slice. \a state is true when user has hovered over the slice and false when hover has moved away from the slice. diff --git a/src/charts/piechart/qpieslice.h b/src/charts/piechart/qpieslice.h index 6a5612b..5e90f14 100644 --- a/src/charts/piechart/qpieslice.h +++ b/src/charts/piechart/qpieslice.h @@ -121,6 +121,9 @@ public: Q_SIGNALS: void clicked(); void hovered(bool state); + void pressed(); + void released(); + void doubleClicked(); void labelChanged(); void valueChanged(); void labelVisibleChanged(); diff --git a/src/charts/scatterchart/scatterchartitem.cpp b/src/charts/scatterchart/scatterchartitem.cpp index 42bced1..12d2f04 100644 --- a/src/charts/scatterchart/scatterchartitem.cpp +++ b/src/charts/scatterchart/scatterchartitem.cpp @@ -41,7 +41,8 @@ ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item) m_pointLabelsVisible(false), m_pointLabelsFormat(series->pointLabelsFormat()), m_pointLabelsFont(series->pointLabelsFont()), - m_pointLabelsColor(series->pointLabelsColor()) + m_pointLabelsColor(series->pointLabelsColor()), + m_mousePressed(false) { QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated())); QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated())); @@ -55,6 +56,7 @@ ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item) setZValue(ChartPresenter::ScatterSeriesZValue); setFlags(QGraphicsItem::ItemClipsChildrenToShape); + setFlag(QGraphicsItem::ItemIsSelectable); handleUpdated(); @@ -112,6 +114,21 @@ void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state) emit XYChart::hovered(m_markerMap[marker], state); } +void ScatterChartItem::markerPressed(QGraphicsItem *marker) +{ + emit XYChart::pressed(m_markerMap[marker]); +} + +void ScatterChartItem::markerReleased(QGraphicsItem *marker) +{ + emit XYChart::released(m_markerMap[marker]); +} + +void ScatterChartItem::markerDoubleClicked(QGraphicsItem *marker) +{ + emit XYChart::doubleClicked(m_markerMap[marker]); +} + void ScatterChartItem::updateGeometry() { diff --git a/src/charts/scatterchart/scatterchartitem_p.h b/src/charts/scatterchart/scatterchartitem_p.h index 7e27b1c..4f1abe0 100644 --- a/src/charts/scatterchart/scatterchartitem_p.h +++ b/src/charts/scatterchart/scatterchartitem_p.h @@ -34,6 +34,7 @@ #include #include #include +#include QT_CHARTS_BEGIN_NAMESPACE @@ -56,6 +57,15 @@ public: 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(); @@ -80,6 +90,9 @@ private: QString m_pointLabelsFormat; QFont m_pointLabelsFont; QColor m_pointLabelsColor; + + QPointF m_lastMousePos; + bool m_mousePressed; }; class CircleMarker: public QGraphicsEllipseItem @@ -91,13 +104,16 @@ public: m_parent(parent) { setAcceptHoverEvents(true); + setFlag(QGraphicsItem::ItemIsSelectable); } protected: void mousePressEvent(QGraphicsSceneMouseEvent *event) { QGraphicsEllipseItem::mousePressEvent(event); - m_parent->markerSelected(this); + m_parent->markerPressed(this); + m_parent->setLastMousePosition(event->pos()); + m_parent->setMousePressed(); } void hoverEnterEvent(QGraphicsSceneHoverEvent *event) { @@ -109,6 +125,19 @@ protected: 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()) + m_parent->markerSelected(this); + m_parent->setMousePressed(false); + } + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) + { + QGraphicsEllipseItem::mouseDoubleClickEvent(event); + m_parent->markerDoubleClicked(this); + } private: ScatterChartItem *m_parent; @@ -123,13 +152,16 @@ public: m_parent(parent) { setAcceptHoverEvents(true); + setFlag(QGraphicsItem::ItemIsSelectable); } protected: void mousePressEvent(QGraphicsSceneMouseEvent *event) { QGraphicsRectItem::mousePressEvent(event); - m_parent->markerSelected(this); + m_parent->markerPressed(this); + m_parent->setLastMousePosition(event->pos()); + m_parent->setMousePressed(); } void hoverEnterEvent(QGraphicsSceneHoverEvent *event) { @@ -141,6 +173,19 @@ protected: 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()) + m_parent->markerSelected(this); + m_parent->setMousePressed(false); + } + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) + { + QGraphicsRectItem::mouseDoubleClickEvent(event); + m_parent->markerDoubleClicked(this); + } private: ScatterChartItem *m_parent; diff --git a/src/charts/splinechart/splinechartitem.cpp b/src/charts/splinechart/splinechartitem.cpp index 1365b2a..2aa9e22 100644 --- a/src/charts/splinechart/splinechartitem.cpp +++ b/src/charts/splinechart/splinechartitem.cpp @@ -36,9 +36,11 @@ SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem *item) m_pointLabelsVisible(false), m_pointLabelsFormat(series->pointLabelsFormat()), m_pointLabelsFont(series->pointLabelsFont()), - m_pointLabelsColor(series->pointLabelsColor()) + 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())); @@ -464,7 +466,9 @@ void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *o void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { - emit XYChart::clicked(domain()->calculateDomainPoint(event->pos())); + emit XYChart::pressed(domain()->calculateDomainPoint(event->pos())); + m_lastMousePos = event->pos(); + m_mousePressed = true; QGraphicsItem::mousePressEvent(event); } @@ -480,6 +484,21 @@ void SplineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) QGraphicsItem::hoverLeaveEvent(event); } +void SplineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) +{ + emit XYChart::released(domain()->calculateDomainPoint(event->pos())); + if (m_lastMousePos == event->pos() && m_mousePressed) + emit XYChart::clicked(domain()->calculateDomainPoint(event->pos())); + m_mousePressed = false; + QGraphicsItem::mouseReleaseEvent(event); +} + +void SplineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) +{ + emit XYChart::doubleClicked(domain()->calculateDomainPoint(event->pos())); + QGraphicsItem::mouseDoubleClickEvent(event); +} + #include "moc_splinechartitem_p.cpp" QT_CHARTS_END_NAMESPACE diff --git a/src/charts/splinechart/splinechartitem_p.h b/src/charts/splinechart/splinechartitem_p.h index d556c75..44765e8 100644 --- a/src/charts/splinechart/splinechartitem_p.h +++ b/src/charts/splinechart/splinechartitem_p.h @@ -66,6 +66,8 @@ protected: void mousePressEvent(QGraphicsSceneMouseEvent *event); void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void hoverLeaveEvent(QGraphicsSceneHoverEvent *event); + void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event); private: QSplineSeries *m_series; @@ -86,6 +88,9 @@ private: QFont m_pointLabelsFont; QColor m_pointLabelsColor; + QPointF m_lastMousePos; + bool m_mousePressed; + friend class SplineAnimation; }; diff --git a/src/charts/xychart/qxyseries.cpp b/src/charts/xychart/qxyseries.cpp index 44371ae..3f71a92 100644 --- a/src/charts/xychart/qxyseries.cpp +++ b/src/charts/xychart/qxyseries.cpp @@ -255,6 +255,54 @@ QT_CHARTS_BEGIN_NAMESPACE */ /*! + \fn void QXYSeries::pressed(const QPointF& point) + \brief Signal is emitted when user presses the \a point on chart. +*/ +/*! + \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 +*/ + +/*! + \fn void QXYSeries::released(const QPointF& point) + \brief Signal is emitted when user releases the \a point on chart. +*/ +/*! + \qmlsignal XYSeries::onReleased(QPointF point) + Signal is emitted when user releases the \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 +*/ + +/*! + \fn void QXYSeries::doubleClicked(const QPointF& point) + \brief Signal is emitted when user doubleclicks the \a point on chart. +*/ +/*! + \qmlsignal XYSeries::onDoubleClicked(QPointF point) + Signal is emitted when user doubleclicks the \a point on chart. 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 +*/ + +/*! \fn void QXYSeries::pointReplaced(int index) Signal is emitted when a point has been replaced at \a index. \sa replace() @@ -288,6 +336,7 @@ QT_CHARTS_BEGIN_NAMESPACE 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. diff --git a/src/charts/xychart/qxyseries.h b/src/charts/xychart/qxyseries.h index 857d9ba..a7f8d8c 100644 --- a/src/charts/xychart/qxyseries.h +++ b/src/charts/xychart/qxyseries.h @@ -97,6 +97,9 @@ public: Q_SIGNALS: void clicked(const QPointF &point); void hovered(const QPointF &point, bool state); + void pressed(const QPointF &point); + void released(const QPointF &point); + void doubleClicked(const QPointF &point); void pointReplaced(int index); void pointRemoved(int index); void pointAdded(int index); diff --git a/src/charts/xychart/xychart.cpp b/src/charts/xychart/xychart.cpp index bd656b0..d0fd6eb 100644 --- a/src/charts/xychart/xychart.cpp +++ b/src/charts/xychart/xychart.cpp @@ -43,6 +43,9 @@ XYChart::XYChart(QXYSeries *series, QGraphicsItem *item): QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int))); QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF))); QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool))); + QObject::connect(this, SIGNAL(pressed(QPointF)), series, SIGNAL(pressed(QPointF))); + QObject::connect(this, SIGNAL(released(QPointF)), series, SIGNAL(released(QPointF))); + QObject::connect(this, SIGNAL(doubleClicked(QPointF)), series, SIGNAL(doubleClicked(QPointF))); } void XYChart::setGeometryPoints(const QVector &points) diff --git a/src/charts/xychart/xychart_p.h b/src/charts/xychart/xychart_p.h index 7f99e05..dfb8026 100644 --- a/src/charts/xychart/xychart_p.h +++ b/src/charts/xychart/xychart_p.h @@ -71,6 +71,9 @@ public Q_SLOTS: Q_SIGNALS: void clicked(const QPointF &point); void hovered(const QPointF &point, bool state); + void pressed(const QPointF &point); + void released(const QPointF &point); + void doubleClicked(const QPointF &point); protected: virtual void updateChart(QVector &oldPoints, QVector &newPoints, int index = -1); diff --git a/src/chartsqml2/declarativeboxplotseries.cpp b/src/chartsqml2/declarativeboxplotseries.cpp index f3bd598..cb11f8c 100644 --- a/src/chartsqml2/declarativeboxplotseries.cpp +++ b/src/chartsqml2/declarativeboxplotseries.cpp @@ -72,6 +72,18 @@ QT_CHARTS_BEGIN_NAMESPACE This signal is emitted when the user clicks with a mouse on top of box-and-whiskers item. */ /*! + \qmlsignal BoxSet::onPressed() + This signal is emitted when the user presses with a mouse on top of box-and-whiskers item. +*/ +/*! + \qmlsignal BoxSet::onReleased() + This signal is emitted when the user releases with a mouse on top of box-and-whiskers item. +*/ +/*! + \qmlsignal BoxSet::onDoubleClicked() + This signal is emitted when the user doubleclicks with a mouse on top of box-and-whiskers item. +*/ +/*! \qmlsignal BoxSet::onHovered(bool status) The signal is emitted if mouse is hovered on top of box-and-whiskers item. Parameter \a status is true, if mouse entered on top of the item, and false if mouse left from top of the item. @@ -335,6 +347,9 @@ DeclarativeBoxPlotSeries::DeclarativeBoxPlotSeries(QQuickItem *parent) : connect(this, SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(onHovered(bool, QBoxSet*))); connect(this, SIGNAL(clicked(QBoxSet*)), this, SLOT(onClicked(QBoxSet*))); connect(this, SIGNAL(brushChanged()), this, SLOT(handleBrushChanged())); + connect(this, SIGNAL(pressed(QBoxSet*)), this, SLOT(onPressed(QBoxSet*))); + connect(this, SIGNAL(released(QBoxSet*)), this, SLOT(onReleased(QBoxSet*))); + connect(this, SIGNAL(doubleClicked(QBoxSet*)), this, SLOT(onDoubleClicked(QBoxSet*))); } void DeclarativeBoxPlotSeries::classBegin() @@ -394,6 +409,21 @@ void DeclarativeBoxPlotSeries::onClicked(QBoxSet *boxset) emit clicked(qobject_cast(boxset)); } +void DeclarativeBoxPlotSeries::onPressed(QBoxSet *boxset) +{ + emit pressed(qobject_cast(boxset)); +} + +void DeclarativeBoxPlotSeries::onReleased(QBoxSet *boxset) +{ + emit released(qobject_cast(boxset)); +} + +void DeclarativeBoxPlotSeries::onDoubleClicked(QBoxSet *boxset) +{ + emit doubleClicked(qobject_cast(boxset)); +} + QString DeclarativeBoxPlotSeries::brushFilename() const { return m_brushFilename; diff --git a/src/chartsqml2/declarativeboxplotseries.h b/src/chartsqml2/declarativeboxplotseries.h index 64bb233..c3b962f 100644 --- a/src/chartsqml2/declarativeboxplotseries.h +++ b/src/chartsqml2/declarativeboxplotseries.h @@ -119,12 +119,18 @@ Q_SIGNALS: void axisYRightChanged(QAbstractAxis *axis); void clicked(DeclarativeBoxSet *boxset); void hovered(bool status, DeclarativeBoxSet *boxset); + void pressed(DeclarativeBoxSet *boxset); + void released(DeclarativeBoxSet *boxset); + void doubleClicked(DeclarativeBoxSet *boxset); Q_REVISION(1) void brushFilenameChanged(const QString &brushFilename); public Q_SLOTS: static void appendSeriesChildren(QQmlListProperty *list, QObject *element); void onHovered(bool status, QBoxSet *boxset); void onClicked(QBoxSet *boxset); + void onPressed(QBoxSet *boxset); + void onReleased(QBoxSet *boxset); + void onDoubleClicked(QBoxSet *boxset); private Q_SLOTS: void handleBrushChanged(); diff --git a/src/chartsqml2/declarativechart.cpp b/src/chartsqml2/declarativechart.cpp index 2d7a1a4..4045f9f 100644 --- a/src/chartsqml2/declarativechart.cpp +++ b/src/chartsqml2/declarativechart.cpp @@ -588,6 +588,31 @@ void DeclarativeChart::hoverMoveEvent(QHoverEvent *event) QApplication::sendEvent(m_scene, &mouseEvent); } +void DeclarativeChart::mouseDoubleClickEvent(QMouseEvent *event) +{ + m_mousePressScenePoint = event->pos(); + m_mousePressScreenPoint = event->globalPos(); + m_lastMouseMoveScenePoint = m_mousePressScenePoint; + m_lastMouseMoveScreenPoint = m_mousePressScreenPoint; + m_mousePressButton = event->button(); + m_mousePressButtons = event->buttons(); + + QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseDoubleClick); + mouseEvent.setWidget(0); + mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint); + mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint); + mouseEvent.setScenePos(m_mousePressScenePoint); + mouseEvent.setScreenPos(m_mousePressScreenPoint); + mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint); + mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint); + mouseEvent.setButtons(m_mousePressButtons); + mouseEvent.setButton(m_mousePressButton); + mouseEvent.setModifiers(event->modifiers()); + mouseEvent.setAccepted(false); + + QApplication::sendEvent(m_scene, &mouseEvent); +} + void DeclarativeChart::handleAntialiasingChanged(bool enable) { setAntialiasing(enable); diff --git a/src/chartsqml2/declarativechart.h b/src/chartsqml2/declarativechart.h index a78ebda..4b35720 100644 --- a/src/chartsqml2/declarativechart.h +++ b/src/chartsqml2/declarativechart.h @@ -112,6 +112,7 @@ protected: void mousePressEvent(QMouseEvent *event); void mouseReleaseEvent(QMouseEvent *event); void hoverMoveEvent(QHoverEvent *event); + void mouseDoubleClickEvent(QMouseEvent *event); private Q_SLOTS: void handleAntialiasingChanged(bool enable); void sceneChanged(QList region); diff --git a/src/chartsqml2/plugins.qmltypes b/src/chartsqml2/plugins.qmltypes index ab15ac3..c3db999 100644 --- a/src/chartsqml2/plugins.qmltypes +++ b/src/chartsqml2/plugins.qmltypes @@ -306,6 +306,18 @@ Module { Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true } } Signal { + name: "pressed" + Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true } + } + Signal { + name: "released" + Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true } + } + Signal { + name: "doubleClicked" + Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true } + } + Signal { name: "brushFilenameChanged" revision: 1 Parameter { name: "brushFilename"; type: "string" } @@ -325,6 +337,18 @@ Module { Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } } Method { + name: "onPressed" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } + Method { + name: "onReleased" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } + Method { + name: "onDoubleClicked" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } + Method { name: "at" type: "DeclarativeBoxSet*" Parameter { name: "index"; type: "int" } @@ -1615,11 +1639,21 @@ Module { Signal { name: "hovered" Parameter { name: "status"; type: "bool" } + Parameter { name: "index"; type: "int" } Parameter { name: "barset"; type: "QBarSet"; isPointer: true } } Signal { - name: "hovered" - Parameter { name: "status"; type: "bool" } + name: "pressed" + Parameter { name: "index"; type: "int" } + Parameter { name: "barset"; type: "QBarSet"; isPointer: true } + } + Signal { + name: "released" + Parameter { name: "index"; type: "int" } + Parameter { name: "barset"; type: "QBarSet"; isPointer: true } + } + Signal { + name: "doubleClicked" Parameter { name: "index"; type: "int" } Parameter { name: "barset"; type: "QBarSet"; isPointer: true } } @@ -1691,6 +1725,18 @@ Module { Parameter { name: "point"; type: "QPointF" } Parameter { name: "state"; type: "bool" } } + Signal { + name: "pressed" + Parameter { name: "point"; type: "QPointF" } + } + Signal { + name: "released" + Parameter { name: "point"; type: "QPointF" } + } + Signal { + name: "doubleClicked" + Parameter { name: "point"; type: "QPointF" } + } Signal { name: "selected" } Signal { name: "colorChanged" @@ -1777,10 +1823,18 @@ Module { Signal { name: "hovered" Parameter { name: "status"; type: "bool" } + Parameter { name: "index"; type: "int" } } Signal { - name: "hovered" - Parameter { name: "status"; type: "bool" } + name: "pressed" + Parameter { name: "index"; type: "int" } + } + Signal { + name: "released" + Parameter { name: "index"; type: "int" } + } + Signal { + name: "doubleClicked" Parameter { name: "index"; type: "int" } } Signal { @@ -1834,6 +1888,18 @@ Module { Parameter { name: "status"; type: "bool" } Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } } + Signal { + name: "pressed" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } + Signal { + name: "released" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } + Signal { + name: "doubleClicked" + Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true } + } Signal { name: "boxOutlineVisibilityChanged" } Signal { name: "boxsetsAdded" @@ -1854,6 +1920,9 @@ Module { name: "hovered" Parameter { name: "status"; type: "bool" } } + Signal { name: "pressed" } + Signal { name: "released" } + Signal { name: "doubleClicked" } Signal { name: "valuesChanged" } Signal { name: "valueChanged" @@ -2073,6 +2142,18 @@ Module { Parameter { name: "slice"; type: "QPieSlice"; isPointer: true } Parameter { name: "state"; type: "bool" } } + Signal { + name: "pressed" + Parameter { name: "slice"; type: "QPieSlice"; isPointer: true } + } + Signal { + name: "released" + Parameter { name: "slice"; type: "QPieSlice"; isPointer: true } + } + Signal { + name: "doubleClicked" + Parameter { name: "slice"; type: "QPieSlice"; isPointer: true } + } } Component { name: "QtCharts::QPieSlice" @@ -2111,6 +2192,9 @@ Module { name: "hovered" Parameter { name: "state"; type: "bool" } } + Signal { name: "pressed" } + Signal { name: "released" } + Signal { name: "doubleClicked" } } Component { name: "QtCharts::QScatterSeries" @@ -2269,6 +2353,18 @@ Module { Parameter { name: "state"; type: "bool" } } Signal { + name: "pressed" + Parameter { name: "point"; type: "QPointF" } + } + Signal { + name: "released" + Parameter { name: "point"; type: "QPointF" } + } + Signal { + name: "doubleClicked" + Parameter { name: "point"; type: "QPointF" } + } + Signal { name: "pointReplaced" Parameter { name: "index"; type: "int" } } diff --git a/tests/auto/qbarseries/tst_qbarseries.cpp b/tests/auto/qbarseries/tst_qbarseries.cpp index 029a445..9f318ee 100644 --- a/tests/auto/qbarseries/tst_qbarseries.cpp +++ b/tests/auto/qbarseries/tst_qbarseries.cpp @@ -69,6 +69,9 @@ private slots: void mousehovered(); void clearWithAnimations(); void destruction(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QBarSeries* m_barseries; @@ -926,6 +929,410 @@ void tst_QBarSeries::destruction() QCOMPARE(spy1.count(), 1); } +void tst_QBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QBarSeries* series = new QBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = (scaleX / setCount) * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left(); + xPos -= series->count()*rectWidth/2; + xPos += set*rectWidth; + + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QBarSeries* series = new QBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = (scaleX / setCount) * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left(); + xPos -= series->count()*rectWidth/2; + xPos += set*rectWidth; + + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QBarSeries* series = new QBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = (scaleX / setCount) * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left(); + xPos -= series->count()*rectWidth/2; + xPos += set*rectWidth; + + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} + QTEST_MAIN(tst_QBarSeries) #include "tst_qbarseries.moc" diff --git a/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp b/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp index 29bb682..a209bec 100644 --- a/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp +++ b/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp @@ -64,6 +64,9 @@ private slots: void mousehovered_data(); void mousehovered(); void clearWithAnimations(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QHorizontalBarSeries* m_barseries; @@ -859,6 +862,409 @@ void tst_QHorizontalBarSeries::clearWithAnimations() series->clear(); } +void tst_QHorizontalBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalBarSeries* series = new QHorizontalBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY; + yPos += setCount*rectHeight/2; + yPos -= set*rectHeight; + + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalBarSeries* series = new QHorizontalBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY; + yPos += setCount*rectHeight/2; + yPos -= set*rectHeight; + + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalBarSeries* series = new QHorizontalBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 10; // From 0 to 10 because of maximum value in set is 10 + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY; + yPos += setCount*rectHeight/2; + yPos -= set*rectHeight; + + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} QTEST_MAIN(tst_QHorizontalBarSeries) #include "tst_qhorizontalbarseries.moc" diff --git a/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp b/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp index 2c3f4bd..add938c 100644 --- a/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp +++ b/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp @@ -52,6 +52,9 @@ private slots: void mousehovered_data(); void mousehovered(); void zeroValuesInSeries(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QHorizontalPercentBarSeries* m_barseries; @@ -604,6 +607,411 @@ void tst_QHorizontalPercentBarSeries::zeroValuesInSeries() QTest::qWaitForWindowShown(&view); } + +void tst_QHorizontalPercentBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 100; // From 0 to 100 because of scaling to 100% + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xPos += rectWidth; + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalPercentBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 100; // From 0 to 100 because of scaling to 100% + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xPos += rectWidth; + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalPercentBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeX = 100; // From 0 to 100 because of scaling to 100% + qreal rangeY = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal xPos = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX; + QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xPos += rectWidth; + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} + QTEST_MAIN(tst_QHorizontalPercentBarSeries) #include "tst_qhorizontalpercentbarseries.moc" diff --git a/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp b/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp index ac6b9b1..cbf64ef 100644 --- a/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp +++ b/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp @@ -51,6 +51,9 @@ private slots: void mouseclicked(); void mousehovered_data(); void mousehovered(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QHorizontalStackedBarSeries* m_barseries; @@ -594,6 +597,424 @@ void tst_QHorizontalStackedBarSeries::mousehovered() QVERIFY(setIndexSpyArg.at(1).toInt() == 1); } +void tst_QHorizontalStackedBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 3; // 3 values per set + qreal rangeX = 20; // From 0 to 20 because bars are stacked (this should be height of highest stack) + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xMax = -scaleX * domainMinX + plotArea.left(); + qreal xMin = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + if (rectWidth > 0) { + QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMax += rectWidth; + } else { + QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMin += rectWidth; + } + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalStackedBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 3; // 3 values per set + qreal rangeX = 20; // From 0 to 20 because bars are stacked (this should be height of highest stack) + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xMax = -scaleX * domainMinX + plotArea.left(); + qreal xMin = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + if (rectWidth > 0) { + QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMax += rectWidth; + } else { + QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMin += rectWidth; + } + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QHorizontalStackedBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 3; // 3 values per set + qreal rangeX = 20; // From 0 to 20 because bars are stacked (this should be height of highest stack) + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = -0.5; // These come from internal domain used by barseries. + qreal domainMinX = 0; // No access to domain from outside, so use hard coded values. + qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect. + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal xMax = -scaleX * domainMinX + plotArea.left(); + qreal xMin = -scaleX * domainMinX + plotArea.left(); + for (int set = 0; set < setCount; set++) { + qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2; + qreal rectWidth = barSets.at(set)->at(i) * scaleX; + if (rectWidth > 0) { + QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMax += rectWidth; + } else { + QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight); + layout.append(rect); + xMin += rectWidth; + } + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} QTEST_MAIN(tst_QHorizontalStackedBarSeries) #include "tst_qhorizontalstackedbarseries.moc" diff --git a/tests/auto/qlineseries/tst_qlineseries.cpp b/tests/auto/qlineseries/tst_qlineseries.cpp index aea9ccc..13f29a1 100644 --- a/tests/auto/qlineseries/tst_qlineseries.cpp +++ b/tests/auto/qlineseries/tst_qlineseries.cpp @@ -36,6 +36,9 @@ public slots: private slots: void qlineseries_data(); void qlineseries(); + void pressedSignal(); + void releasedSignal(); + void doubleClickedSignal(); protected: void pointsVisible_data(); }; @@ -102,6 +105,99 @@ void tst_QLineSeries::qlineseries() 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 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(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 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(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); + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QList 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(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" diff --git a/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp b/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp index e4bab70..a74c651 100644 --- a/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp +++ b/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp @@ -52,6 +52,9 @@ private slots: void mousehovered_data(); void mousehovered(); void zeroValuesInSeries(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QPercentBarSeries* m_barseries; @@ -608,6 +611,416 @@ void tst_QPercentBarSeries::zeroValuesInSeries() QTest::qWaitForWindowShown(&view); } +void tst_QPercentBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPercentBarSeries* series = new QPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 100; // From 0 to 100 because range is scaled to 100% + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY; + + QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth); + layout.append(rect); + yPos -= rectHeigth; + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QPercentBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPercentBarSeries* series = new QPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 100; // From 0 to 100 because range is scaled to 100% + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY; + + QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth); + layout.append(rect); + yPos -= rectHeigth; + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QPercentBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPercentBarSeries* series = new QPercentBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 100; // From 0 to 100 because range is scaled to 100% + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal colSum = 20; // Sum of values in column (10 + 10 in our test case) + qreal percentage = (100 / colSum); + qreal yPos = height + scaleY * domainMinY + plotArea.top(); + + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY; + + QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth); + layout.append(rect); + yPos -= rectHeigth; + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} + QTEST_MAIN(tst_QPercentBarSeries) #include "tst_qpercentbarseries.moc" diff --git a/tests/auto/qpieseries/tst_qpieseries.cpp b/tests/auto/qpieseries/tst_qpieseries.cpp index ce7e8d5..9d975c5 100644 --- a/tests/auto/qpieseries/tst_qpieseries.cpp +++ b/tests/auto/qpieseries/tst_qpieseries.cpp @@ -57,6 +57,9 @@ private slots: void hoverSignal(); void sliceSeries(); void destruction(); + void pressedSignal(); + void releasedSignal(); + void doubleClickedSignal(); private: void verifyCalculatedData(const QPieSeries &series, bool *ok); @@ -652,6 +655,139 @@ QList tst_qpieseries::slicePoints(QRectF rect) return points; } +void tst_qpieseries::pressedSignal() +{ + // NOTE: + // This test is the same as tst_qpieslice::pressedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // add some slices + QPieSlice *s1 = m_series->append("slice 1", 1); + QPieSlice *s2 = m_series->append("slice 2", 1); + QPieSlice *s3 = m_series->append("slice 3", 1); + QPieSlice *s4 = m_series->append("slice 4", 1); + QSignalSpy clickSpy(m_series, SIGNAL(pressed(QPieSlice*))); + + // add series to the chart + m_view->chart()->legend()->setVisible(false); + m_view->chart()->addSeries(m_series); + m_view->show(); + QTest::qWaitForWindowShown(m_view); + + // test maximum size + m_series->setPieSize(1.0); + QRectF pieRect = m_view->chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3)); + TRY_COMPARE(clickSpy.count(), 4); + QCOMPARE(qvariant_cast(clickSpy.at(0).at(0)), s1); + QCOMPARE(qvariant_cast(clickSpy.at(1).at(0)), s2); + QCOMPARE(qvariant_cast(clickSpy.at(2).at(0)), s3); + QCOMPARE(qvariant_cast(clickSpy.at(3).at(0)), s4); + clickSpy.clear(); + + // test half size + m_series->setPieSize(0.5); + m_series->setVerticalPosition(0.25); + m_series->setHorizontalPosition(0.25); + pieRect = QRectF(m_view->chart()->plotArea().topLeft(), m_view->chart()->plotArea().center()); + points = slicePoints(pieRect); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3)); + TRY_COMPARE(clickSpy.count(), 4); + QCOMPARE(qvariant_cast(clickSpy.at(0).at(0)), s1); + QCOMPARE(qvariant_cast(clickSpy.at(1).at(0)), s2); + QCOMPARE(qvariant_cast(clickSpy.at(2).at(0)), s3); + QCOMPARE(qvariant_cast(clickSpy.at(3).at(0)), s4); +} + +void tst_qpieseries::releasedSignal() +{ + // NOTE: + // This test is the same as tst_qpieslice::pressedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // add some slices + QPieSlice *s1 = m_series->append("slice 1", 1); + QPieSlice *s2 = m_series->append("slice 2", 1); + QPieSlice *s3 = m_series->append("slice 3", 1); + QPieSlice *s4 = m_series->append("slice 4", 1); + QSignalSpy clickSpy(m_series, SIGNAL(released(QPieSlice*))); + + // add series to the chart + m_view->chart()->legend()->setVisible(false); + m_view->chart()->addSeries(m_series); + m_view->show(); + QTest::qWaitForWindowShown(m_view); + + // test maximum size + m_series->setPieSize(1.0); + QRectF pieRect = m_view->chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3)); + TRY_COMPARE(clickSpy.count(), 4); + QCOMPARE(qvariant_cast(clickSpy.at(0).at(0)), s1); + QCOMPARE(qvariant_cast(clickSpy.at(1).at(0)), s2); + QCOMPARE(qvariant_cast(clickSpy.at(2).at(0)), s3); + QCOMPARE(qvariant_cast(clickSpy.at(3).at(0)), s4); + clickSpy.clear(); + + // test half size + m_series->setPieSize(0.5); + m_series->setVerticalPosition(0.25); + m_series->setHorizontalPosition(0.25); + pieRect = QRectF(m_view->chart()->plotArea().topLeft(), m_view->chart()->plotArea().center()); + points = slicePoints(pieRect); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3)); + TRY_COMPARE(clickSpy.count(), 4); + QCOMPARE(qvariant_cast(clickSpy.at(0).at(0)), s1); + QCOMPARE(qvariant_cast(clickSpy.at(1).at(0)), s2); + QCOMPARE(qvariant_cast(clickSpy.at(2).at(0)), s3); + QCOMPARE(qvariant_cast(clickSpy.at(3).at(0)), s4); +} + +void tst_qpieseries::doubleClickedSignal() +{ + // NOTE: + // This test is the same as tst_qpieslice::pressedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // add some slices + QPieSlice *s1 = m_series->append("slice 1", 1); + QSignalSpy clickSpy(m_series, SIGNAL(doubleClicked(QPieSlice*))); + + // add series to the chart + m_view->chart()->legend()->setVisible(false); + m_view->chart()->addSeries(m_series); + m_view->show(); + QTest::qWaitForWindowShown(m_view); + + // test maximum size + m_series->setPieSize(1.0); + QRectF pieRect = m_view->chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseDClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0)); + TRY_COMPARE(clickSpy.count(), 1); + QCOMPARE(qvariant_cast(clickSpy.at(0).at(0)), s1); +} + QTEST_MAIN(tst_qpieseries) #include "tst_qpieseries.moc" diff --git a/tests/auto/qpieslice/tst_qpieslice.cpp b/tests/auto/qpieslice/tst_qpieslice.cpp index 16099cf..9887d36 100644 --- a/tests/auto/qpieslice/tst_qpieslice.cpp +++ b/tests/auto/qpieslice/tst_qpieslice.cpp @@ -43,6 +43,9 @@ private slots: void customize(); void clickedSignal(); void hoverSignal(); + void pressedSignal(); + void releasedSignal(); + void doubleClickedSignal(); private: QList slicePoints(QRectF rect); @@ -335,6 +338,114 @@ QList tst_qpieslice::slicePoints(QRectF rect) return points; } +void tst_qpieslice::pressedSignal() +{ + // NOTE: + // This test is the same as tst_qpieseries::pressedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // create a pie series + QPieSeries *series = new QPieSeries(); + QPieSlice *s1 = series->append("slice 1", 1); + QPieSlice *s2 = series->append("slice 2", 1); + QPieSlice *s3 = series->append("slice 3", 1); + QPieSlice *s4 = series->append("slice 4", 1); + QSignalSpy clickSpy1(s1, SIGNAL(pressed())); + QSignalSpy clickSpy2(s2, SIGNAL(pressed())); + QSignalSpy clickSpy3(s3, SIGNAL(pressed())); + QSignalSpy clickSpy4(s4, SIGNAL(pressed())); + + // add series to the chart + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // simulate clicks + series->setPieSize(1.0); + QRectF pieRect = view.chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(3)); + QCOMPARE(clickSpy1.count(), 1); + QCOMPARE(clickSpy2.count(), 1); + QCOMPARE(clickSpy3.count(), 1); + QCOMPARE(clickSpy4.count(), 1); +} + +void tst_qpieslice::releasedSignal() +{ + // NOTE: + // This test is the same as tst_qpieseries::releasedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // create a pie series + QPieSeries *series = new QPieSeries(); + QPieSlice *s1 = series->append("slice 1", 1); + QPieSlice *s2 = series->append("slice 2", 1); + QPieSlice *s3 = series->append("slice 3", 1); + QPieSlice *s4 = series->append("slice 4", 1); + QSignalSpy clickSpy1(s1, SIGNAL(released())); + QSignalSpy clickSpy2(s2, SIGNAL(released())); + QSignalSpy clickSpy3(s3, SIGNAL(released())); + QSignalSpy clickSpy4(s4, SIGNAL(released())); + + // add series to the chart + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // simulate clicks + series->setPieSize(1.0); + QRectF pieRect = view.chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(0)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(1)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(2)); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(3)); + QCOMPARE(clickSpy1.count(), 1); + QCOMPARE(clickSpy2.count(), 1); + QCOMPARE(clickSpy3.count(), 1); + QCOMPARE(clickSpy4.count(), 1); +} + +void tst_qpieslice::doubleClickedSignal() +{ + // NOTE: + // This test is the same as tst_qpieseries::doubleClickedSignal() + // Just for different signals. + + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + // create a pie series + QPieSeries *series = new QPieSeries(); + QPieSlice *s1 = series->append("slice 1", 1); + QSignalSpy clickSpy1(s1, SIGNAL(doubleClicked())); + + // add series to the chart + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // simulate clicks + series->setPieSize(1.0); + QRectF pieRect = view.chart()->plotArea(); + QList points = slicePoints(pieRect); + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, points.at(0)); + QCOMPARE(clickSpy1.count(), 1); +} + QTEST_MAIN(tst_qpieslice) #include "tst_qpieslice.moc" diff --git a/tests/auto/qscatterseries/tst_qscatterseries.cpp b/tests/auto/qscatterseries/tst_qscatterseries.cpp index c68d999..3872c7b 100644 --- a/tests/auto/qscatterseries/tst_qscatterseries.cpp +++ b/tests/auto/qscatterseries/tst_qscatterseries.cpp @@ -36,6 +36,9 @@ private slots: void qscatterseries_data(); void qscatterseries(); void scatterChangedSignals(); + void pressedSignal(); + void releasedSignal(); + void doubleClickedSignal(); protected: void pointsVisible_data(); @@ -126,6 +129,99 @@ void tst_QScatterSeries::scatterChangedSignals() TRY_COMPARE(colorSpy.count(), 2); } +void tst_QScatterSeries::pressedSignal() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPointF scatterPoint(4, 12); + QScatterSeries *scatterSeries = new QScatterSeries(); + scatterSeries->append(QPointF(2, 1)); + scatterSeries->append(scatterPoint); + scatterSeries->append(QPointF(6, 12)); + + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(scatterSeries); + view.show(); + QTest::qWaitForWindowShown(&view); + + QSignalSpy seriesSpy(scatterSeries, SIGNAL(pressed(QPointF))); + + QPointF checkPoint = view.chart()->mapToPosition(scatterPoint); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QList 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(seriesSpyArg.at(0)); + QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x())); + QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y())); +} + +void tst_QScatterSeries::releasedSignal() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPointF scatterPoint(4, 12); + QScatterSeries *scatterSeries = new QScatterSeries(); + scatterSeries->append(QPointF(2, 1)); + scatterSeries->append(scatterPoint); + scatterSeries->append(QPointF(6, 12)); + + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(scatterSeries); + view.show(); + QTest::qWaitForWindowShown(&view); + + QSignalSpy seriesSpy(scatterSeries, SIGNAL(released(QPointF))); + + QPointF checkPoint = view.chart()->mapToPosition(scatterPoint); + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QList 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(seriesSpyArg.at(0)); + QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x())); + QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y())); +} + +void tst_QScatterSeries::doubleClickedSignal() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QPointF scatterPoint(4, 12); + QScatterSeries *scatterSeries = new QScatterSeries(); + scatterSeries->append(QPointF(2, 1)); + scatterSeries->append(scatterPoint); + scatterSeries->append(QPointF(6, 12)); + + QChartView view; + view.chart()->legend()->setVisible(false); + view.chart()->addSeries(scatterSeries); + view.show(); + QTest::qWaitForWindowShown(&view); + + QSignalSpy seriesSpy(scatterSeries, SIGNAL(doubleClicked(QPointF))); + + QPointF checkPoint = view.chart()->mapToPosition(scatterPoint); + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QList 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(seriesSpyArg.at(0)); + QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x())); + QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y())); +} + QTEST_MAIN(tst_QScatterSeries) #include "tst_qscatterseries.moc" diff --git a/tests/auto/qsplineseries/tst_qsplineseries.cpp b/tests/auto/qsplineseries/tst_qsplineseries.cpp index b72ac81..8041d28 100644 --- a/tests/auto/qsplineseries/tst_qsplineseries.cpp +++ b/tests/auto/qsplineseries/tst_qsplineseries.cpp @@ -35,6 +35,9 @@ public slots: private slots: void qsplineseries_data(); void qsplineseries(); + void pressedSignal(); + void releasedSignal(); + void doubleClickedSignal(); protected: void pointsVisible_data(); }; @@ -95,6 +98,98 @@ void tst_QSplineSeries::qsplineseries() 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 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(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 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(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); + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QList 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(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" diff --git a/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp b/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp index a5df87d..bda9470 100644 --- a/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp +++ b/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp @@ -51,6 +51,9 @@ private slots: void mouseclicked(); void mousehovered_data(); void mousehovered(); + void mousePressed(); + void mouseReleased(); + void mouseDoubleClicked(); private: QStackedBarSeries* m_barseries; @@ -595,6 +598,424 @@ void tst_QStackedBarSeries::mousehovered() QVERIFY(setIndexSpyArg.at(1).toInt() == 1); } +void tst_QStackedBarSeries::mousePressed() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QStackedBarSeries* series = new QStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(pressed(int))); + QSignalSpy setSpy2(set2, SIGNAL(pressed(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 20; // From 0 to 20 because sets are stacked (this should be height of highest stack) + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yMax = height + scaleY * domainMinY + plotArea.top(); + qreal yMin = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + if (rectHeight < 0) { + QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMax -= rectHeight; + } else { + QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMin -= rectHeight; + } + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QStackedBarSeries::mouseReleased() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QStackedBarSeries* series = new QStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(released(int))); + QSignalSpy setSpy2(set2, SIGNAL(released(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 20; // From 0 to 20 because sets are stacked (this should be height of highest stack) + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yMax = height + scaleY * domainMinY + plotArea.top(); + qreal yMin = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + if (rectHeight < 0) { + QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMax -= rectHeight; + } else { + QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMin -= rectHeight; + } + } + } + +//==================================================================================== +// barset 1, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 1, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 1, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); + +//==================================================================================== +// barset 2, bar 0 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); + +//==================================================================================== +// barset 2, bar 1 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 1); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 1); + +//==================================================================================== +// barset 2, bar 2 + QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 0); + QCOMPARE(setSpy2.count(), 1); + + seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set2); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 2); + + setSpyArg = setSpy2.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 2); +} + +void tst_QStackedBarSeries::mouseDoubleClicked() +{ + SKIP_IF_CANNOT_TEST_MOUSE_EVENTS(); + + QStackedBarSeries* series = new QStackedBarSeries(); + + QBarSet* set1 = new QBarSet(QString("set 1")); + *set1 << 10 << 10 << 10; + series->append(set1); + + QBarSet* set2 = new QBarSet(QString("set 2")); + *set2 << 10 << 10 << 10; + series->append(set2); + QList barSets = series->barSets(); + + QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*))); + QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int))); + QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int))); + + QChartView view(new QChart()); + view.resize(400,300); + view.chart()->addSeries(series); + view.show(); + QTest::qWaitForWindowShown(&view); + + // Calculate expected layout for bars + QRectF plotArea = view.chart()->plotArea(); + qreal width = plotArea.width(); + qreal height = plotArea.height(); + qreal rangeY = 20; // From 0 to 20 because sets are stacked (this should be height of highest stack) + qreal rangeX = 3; // 3 values per set + qreal scaleY = (height / rangeY); + qreal scaleX = (width / rangeX); + + qreal setCount = series->count(); + qreal domainMinY = 0; // These come from internal domain used by barseries. + qreal domainMinX = -0.5; // No access to domain from outside, so use hard coded values. + qreal rectWidth = scaleX * series->barWidth(); + + QVector layout; + + // 3 = count of values in set + // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.) + for (int i = 0; i < 3; i++) { + qreal yMax = height + scaleY * domainMinY + plotArea.top(); + qreal yMin = height + scaleY * domainMinY + plotArea.top(); + for (int set = 0; set < setCount; set++) { + qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2; + qreal rectHeight = barSets.at(set)->at(i) * scaleY; + if (rectHeight < 0) { + QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMax -= rectHeight; + } else { + QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight); + layout.append(rect); + yMin -= rectHeight; + } + } + } + + // barset 1, bar 0 + QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint()); + QCoreApplication::processEvents(QEventLoop::AllEvents, 1000); + + QCOMPARE(seriesSpy.count(), 1); + QCOMPARE(setSpy1.count(), 1); + QCOMPARE(setSpy2.count(), 0); + + QList seriesSpyArg = seriesSpy.takeFirst(); + QCOMPARE(qvariant_cast(seriesSpyArg.at(1)), set1); + QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int); + QVERIFY(seriesSpyArg.at(0).toInt() == 0); + + QList setSpyArg = setSpy1.takeFirst(); + QVERIFY(setSpyArg.at(0).type() == QVariant::Int); + QVERIFY(setSpyArg.at(0).toInt() == 0); +} QTEST_MAIN(tst_QStackedBarSeries) #include "tst_qstackedbarseries.moc" diff --git a/tests/manual/boxplottester/mainwidget.cpp b/tests/manual/boxplottester/mainwidget.cpp index 784512d..81a05f6 100644 --- a/tests/manual/boxplottester/mainwidget.cpp +++ b/tests/manual/boxplottester/mainwidget.cpp @@ -250,8 +250,15 @@ void MainWidget::addSeries() m_series[m_seriesCount]->setName("Box & Whiskers"); connect(m_series[m_seriesCount], SIGNAL(clicked(QBoxSet*)), this, SLOT(boxClicked(QBoxSet*))); + connect(m_series[m_seriesCount], SIGNAL(pressed(QBoxSet*)), this, SLOT(boxPressed(QBoxSet*))); + connect(m_series[m_seriesCount], SIGNAL(released(QBoxSet*)), this, SLOT(boxReleased(QBoxSet*))); + connect(m_series[m_seriesCount], SIGNAL(doubleClicked(QBoxSet*)), + this, SLOT(boxDoubleClicked(QBoxSet*))); connect(m_series[m_seriesCount], SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(boxHovered(bool, QBoxSet*))); connect(set1, SIGNAL(clicked()), this, SLOT(singleBoxClicked())); + connect(set1, SIGNAL(pressed()), this, SLOT(singleBoxPressed())); + connect(set1, SIGNAL(released()), this, SLOT(singleBoxReleased())); + connect(set1, SIGNAL(doubleClicked()), this, SLOT(singleBoxDoubleClicked())); connect(set2, SIGNAL(hovered(bool)), this, SLOT(singleBoxHovered(bool))); m_series[m_seriesCount]->setBoxOutlineVisible(m_boxOutlined->checkState()); @@ -453,11 +460,41 @@ void MainWidget::boxHovered(bool state, QBoxSet *set) qDebug() << "box median " << set->at(QBoxSet::Median) << " hover ended"; } +void MainWidget::boxPressed(QBoxSet *set) +{ + qDebug() << "boxPressed, median = " << set->at(QBoxSet::Median); +} + +void MainWidget::boxReleased(QBoxSet *set) +{ + qDebug() << "boxReleased, median = " << set->at(QBoxSet::Median); +} + +void MainWidget::boxDoubleClicked(QBoxSet *set) +{ + qDebug() << "boxDoubleClicked, median = " << set->at(QBoxSet::Median); +} + void MainWidget::singleBoxClicked() { qDebug() << "singleBoxClicked"; } +void MainWidget::singleBoxPressed() +{ + qDebug() << "singleBoxPressed"; +} + +void MainWidget::singleBoxReleased() +{ + qDebug() << "singleBoxReleased"; +} + +void MainWidget::singleBoxDoubleClicked() +{ + qDebug() << "singleBoxDoubleClicked"; +} + void MainWidget::singleBoxHovered(bool state) { if (state) diff --git a/tests/manual/boxplottester/mainwidget.h b/tests/manual/boxplottester/mainwidget.h index cbb2cd3..00f835b 100644 --- a/tests/manual/boxplottester/mainwidget.h +++ b/tests/manual/boxplottester/mainwidget.h @@ -66,8 +66,14 @@ private slots: void changeChartTheme(int themeIndex); void boxClicked(QBoxSet *set); void boxHovered(bool state, QBoxSet *set); + void boxPressed(QBoxSet *set); + void boxReleased(QBoxSet *set); + void boxDoubleClicked(QBoxSet *set); void singleBoxClicked(); void singleBoxHovered(bool state); + void singleBoxPressed(); + void singleBoxReleased(); + void singleBoxDoubleClicked(); void changePen(); void antialiasingToggled(bool); void boxOutlineToggled(bool); diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml index 069e17d..d94f8a2 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml @@ -81,6 +81,9 @@ ChartView { + font.family); onPointLabelsColorChanged: console.log(name + ".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); } AreaSeries { @@ -107,5 +110,8 @@ ChartView { onSelected: console.log(name + ".onSelected"); onColorChanged: console.log(name + ".onColorChanged: " + color); onBorderColorChanged: console.log(name + ".onBorderColorChanged: " + borderColor); + 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); } } diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml index ad08864..45bd494 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml @@ -51,6 +51,10 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); + } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -65,6 +69,9 @@ ChartView { onCountChanged: console.log("barSeries.onCountChanged: " + count); onLabelsFormatChanged: console.log("barSeries.onLabelsFormatChanged: " + format); onLabelsPositionChanged: console.log("barSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("barSeries.onPressed: " + barset + " " + index); + onReleased: console.log("barSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("barSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter) diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml index aedb26c..278d296 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml @@ -50,6 +50,9 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -66,6 +69,9 @@ ChartView { + format); onLabelsPositionChanged: console.log("horizontalBarSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("horizontalBarSeries.onPressed: " + barset + " " + index); + onReleased: console.log("horizontalBarSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("horizontalBarSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter) diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml index c0d1b44..eab84f7 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml @@ -50,6 +50,9 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -68,6 +71,9 @@ ChartView { onLabelsPositionChanged: console.log( "horizontalPercentBarSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("horizontalPercentBarSeries.onPressed: " + barset + " " + index); + onReleased: console.log("horizontalPercentBarSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("horizontalPercentBarSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter) diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml index 3b94e89..ab79dc5 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml @@ -50,6 +50,9 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -68,6 +71,9 @@ ChartView { onLabelsPositionChanged: console.log( "horizontalStackedBarSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("horizontalStackedBarSeries.onPressed: " + barset + " " + index); + onReleased: console.log("horizontalStackedBarSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("horizontalStackedBarSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter) diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml index de3134a..6e16918 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml @@ -62,6 +62,9 @@ ChartView { + font.family); onPointLabelsColorChanged: console.log("lineSeries.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); } LineSeries { @@ -74,5 +77,8 @@ ChartView { XYPoint { x: 4.1; y: 2.3 } 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); } } diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml index 74c9b88..c595873 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml @@ -51,6 +51,9 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -67,6 +70,9 @@ ChartView { + format); onLabelsPositionChanged: console.log("percentBarSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("percentBarSeries.onPressed: " + barset + " " + index); + onReleased: console.log("percentBarSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("percentBarSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter) diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml index 37a321a..675ae3e 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml @@ -47,6 +47,9 @@ ChartView { onAngleSpanChanged: console.log("slice.onAngleSpanChanged: " + angleSpan); onClicked: console.log("slice.onClicked: " + label); onHovered: console.log("slice.onHovered: " + state); + onPressed: console.log("slice.onPressed: " + label); + onReleased: console.log("slice.onReleased: " + label); + onDoubleClicked: console.log("slice.onDoubleClicked: " + label); } PieSlice { label: "slice2"; value: 22 } PieSlice { label: "slice3"; value: 33 } @@ -63,5 +66,8 @@ ChartView { onSliceRemoved: console.log("pieSeries.onSliceRemoved: " + slice.label); onCountChanged: console.log("pieSeries.onCountChanged: " + count); onSumChanged: console.log("pieSeries.onSumChanged: " + sum); + onPressed: console.log("pieSeries.onPressed: " + slice.label); + onReleased: console.log("pieSeries.onReleased: " + slice.label); + onDoubleClicked: console.log("pieSeries.onDoubleClicked: " + slice.label); } } diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml index d531ac3..2b81553 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml @@ -59,6 +59,9 @@ ChartView { + font.family); onPointLabelsColorChanged: console.log("lineSeries.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 { @@ -71,5 +74,8 @@ ChartView { 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); } } diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml index 3a182d1..fd78a44 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml @@ -61,6 +61,9 @@ ChartView { + font.family); onPointLabelsColorChanged: console.log("splineSeries.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); } SplineSeries { @@ -73,5 +76,8 @@ ChartView { XYPoint { x: 4.1; y: 2.3 } 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); } } diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml index a59f0e1..aff7836 100644 --- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml +++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml @@ -50,6 +50,9 @@ ChartView { onValuesAdded: console.log("barset.onValuesAdded: " + index + ", " + count); onValuesRemoved: console.log("barset.onValuesRemoved: " + index + ", " + count); onValueChanged: console.log("barset.onValuesChanged: " + index); + onPressed: console.log("barset.onPressed: " + index); + onReleased: console.log("barset.onReleased: " + index); + onDoubleClicked: console.log("barset.onDoubleClicked: " + index); } BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] } BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] } @@ -66,6 +69,9 @@ ChartView { + format); onLabelsPositionChanged: console.log("stackedBarSeries.onLabelsPositionChanged: " + series.labelsPosition); + onPressed: console.log("stackedBarSeries.onPressed: " + barset + " " + index); + onReleased: console.log("stackedBarSeries.onReleased: " + barset + " " + index); + onDoubleClicked: console.log("stackedBarSeries.onDoubleClicked: " + barset + " " + index); function changeLabelsPosition() { if (labelsPosition === BarSeries.LabelsCenter)