HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1280:dde538c774a3

pie: make it impossible to add negative slice values

Jani Honkonen -

r1280:dde538c774a3

parent child

Context file:

r1280:dde538c774a3

Collapse all files

src/piechart/qpieslice.cpp +5 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme.
                 Note that if the user has customized slices and theme is changed all customizations will be lost.
                 To enable user interaction with the pie some basic signals are provided about clicking and hovering.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
                 \sa labelVisible, labelPen, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
+                Note that if users sets a negative value it is converted to a positive value.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 \fn void QPieSlice::valueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
                 \property QPieSlice::labelVisible
                 Defienes the visibility of the slice label.
                 Default is not visible.
                 \sa label, labelPen, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::exploded
                 Defines if the slice is exploded from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \fn void QPieSlice::explodedChanged()
                 This signal is emitted the the slice has been exploded from the pie or is returned back to the pie.
                 \sa exploded
             */
             /*!
                 \property QPieSlice::pen
                 Pen used to draw the slice border.
             */
             /*!
                 \fn void QPieSlice::penChanged()
                 This signal is emitted when the pen of the slice has changed.
                 \sa pen
             */
             /*!
                 \property QPieSlice::brush
                 Brush used to draw the slice.
             */
             /*!
                 \fn void QPieSlice::brushChanged()
                 This signal is emitted when the brush of the slice has changed.
                 \sa brush
             */
             /*!
                 \property QPieSlice::labelPen
                 Pen used to draw label and label arm of the slice.
                 \sa label, labelVisible, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelPenChanged()
                 This signal is emitted when the label pen of the slice has changed.
                 \sa labelPen
             */
             /*!
                 \property QPieSlice::labelFont
                 Font used for drawing label text.
                 \sa label, labelVisible, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelFontChanged()
                 This signal is emitted when the label font of the slice has changed.
                 \sa labelFont
             */
             /*!
                 \property QPieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa label, labelVisible, labelPen, labelFont
             */
             /*!
                 \fn void QPieSlice::labelArmLengthFactorChanged()
                 This signal is emitted when the label arm factor of the slice has changed.
                 \sa labelArmLengthFactor
             */
             /*!
                 \property QPieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa exploded
             */
             /*!
                 \fn void QPieSlice::explodeDistanceFactorChanged()
                 This signal is emitted when the explode distance factor of the slice has changed.
                 \sa explodeDistanceFactor
             */
             /*!
                 \property QPieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
                 \sa value, QPieSeries::sum
             */
             /*!
                 \fn void QPieSlice::percentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
                 \property QPieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::startAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
                 \property QPieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::angleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \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.
                 \sa QPieSeries::hovered()
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
-                d_ptr->m_data.m_value = value;
+                setValue(value);
-                d_ptr->m_data.m_labelText = label;
+                setLabel(label);
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
             }
             void QPieSlice::setLabel(QString label)
             {
                 if (d_ptr->m_data.m_labelText != label) {
                     d_ptr->m_data.m_labelText = label;
                     emit labelChanged();
                 }
             }
             QString QPieSlice::label() const
             {
                 return d_ptr->m_data.m_labelText;
             }
             void QPieSlice::setValue(qreal value)
             {
+                value = qAbs(value); // negative values not allowed
                 if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
                     d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             }
             qreal QPieSlice::value() const
             {
                 return d_ptr->m_data.m_value;
             }
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d_ptr->m_data.m_isLabelVisible != visible) {
                     d_ptr->m_data.m_isLabelVisible = visible;
                     emit labelVisibleChanged();
                 }
             }
             bool QPieSlice::isLabelVisible() const
             {
                 return d_ptr->m_data.m_isLabelVisible;
             }
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d_ptr->m_data.m_isExploded != exploded) {
                     d_ptr->m_data.m_isExploded = exploded;
                     emit explodedChanged();
                 }
             }
             bool QPieSlice::isExploded() const
             {
                 return d_ptr->m_data.m_isExploded;
             }
             void QPieSlice::setPen(const QPen &pen)
             {
                 d_ptr->setPen(pen, false);
             }
             QPen QPieSlice::pen() const
             {
                 return d_ptr->m_data.m_slicePen;
             }
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 d_ptr->setBrush(brush, false);
             }
             QBrush QPieSlice::brush() const
             {
                 return d_ptr->m_data.m_sliceBrush;
             }
             void QPieSlice::setLabelPen(const QPen &pen)
             {
                 d_ptr->setLabelPen(pen, false);
             }
             QPen QPieSlice::labelPen() const
             {
                 return d_ptr->m_data.m_labelPen;
             }
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 d_ptr->setLabelFont(font, false);
             }
             QFont QPieSlice::labelFont() const
             {
                 return d_ptr->m_data.m_labelFont;
             }
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
                     d_ptr->m_data.m_labelArmLengthFactor = factor;
                     emit labelArmLengthFactorChanged();
                 }
             }
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d_ptr->m_data.m_labelArmLengthFactor;
             }
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
                     d_ptr->m_data.m_explodeDistanceFactor = factor;
                     emit explodeDistanceFactorChanged();
                 }
             }
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d_ptr->m_data.m_explodeDistanceFactor;
             }
             qreal QPieSlice::percentage() const
             {
                 return d_ptr->m_data.m_percentage;
             }
             qreal QPieSlice::startAngle() const
             {
                 return d_ptr->m_data.m_startAngle;
             }
             qreal QPieSlice::angleSpan() const
             {
                 return d_ptr->m_data.m_angleSpan;
             }
             QPieSlicePrivate::QPieSlicePrivate(QPieSlice *parent)
                 :QObject(parent),
                 q_ptr(parent)
             {
             }
             QPieSlicePrivate::~QPieSlicePrivate()
             {
             }
             QPieSlicePrivate *QPieSlicePrivate::fromSlice(QPieSlice *slice)
             {
                 return slice->d_func();
             }
             void QPieSlicePrivate::setPen(const QPen &pen, bool themed)
             {
                 if (m_data.m_slicePen != pen) {
                     m_data.m_slicePen = pen;
                     m_data.m_slicePen.setThemed(themed);
                     emit q_ptr->penChanged();
                 }
             }
             void QPieSlicePrivate::setBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_sliceBrush != brush) {
                     m_data.m_sliceBrush = brush;
                     m_data.m_sliceBrush.setThemed(themed);
                     emit q_ptr->brushChanged();
                 }
             }
             void QPieSlicePrivate::setLabelPen(const QPen &pen, bool themed)
             {
                 if (m_data.m_labelPen != pen) {
                     m_data.m_labelPen = pen;
                     m_data.m_labelPen.setThemed(themed);
                     emit q_ptr->labelPenChanged();
                 }
             }
             void QPieSlicePrivate::setLabelFont(const QFont &font, bool themed)
             {
                 if (m_data.m_labelFont != font) {
                     m_data.m_labelFont = font;
                     m_data.m_labelFont.setThemed(themed);
                     emit q_ptr->labelFontChanged();
                 }
             }
             void QPieSlicePrivate::setPercentage(qreal percentage)
             {
                 if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
                     m_data.m_percentage = percentage;
                     emit q_ptr->percentageChanged();
                 }
             }
             void QPieSlicePrivate::setStartAngle(qreal angle)
             {
                 if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
                     m_data.m_startAngle = angle;
                     emit q_ptr->startAngleChanged();
                 }
             }
             void QPieSlicePrivate::setAngleSpan(qreal span)
             {
                 if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
                     m_data.m_angleSpan = span;
                     emit q_ptr->angleSpanChanged();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"
             #include "moc_qpieslice_p.cpp"

tests/auto/qpieslice/tst_qpieslice.cpp +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <tst_definitions.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieslice.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_qpieslice : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void changedSignals();
                 void customize();
                 void mouseClick();
                 void mouseHover();
             private:
             private:
             };
             void tst_qpieslice::initTestCase()
             {
             }
             void tst_qpieslice::cleanupTestCase()
             {
             }
             void tst_qpieslice::init()
             {
             }
             void tst_qpieslice::cleanup()
             {
             }
             void tst_qpieslice::construction()
             {
                 // no params
                 QPieSlice slice1;
                 QCOMPARE(slice1.value(), 0.0);
                 QVERIFY(slice1.label().isEmpty());
                 QVERIFY(!slice1.isLabelVisible());
                 QVERIFY(!slice1.isExploded());
                 QCOMPARE(slice1.pen(), QPen());
                 QCOMPARE(slice1.brush(), QBrush());
                 QCOMPARE(slice1.labelPen(), QPen());
                 QCOMPARE(slice1.labelFont(), QFont());
                 QCOMPARE(slice1.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice1.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice1.percentage(), 0.0);
                 QCOMPARE(slice1.startAngle(), 0.0);
                 QCOMPARE(slice1.angleSpan(), 0.0);
                 // value and label params
                 QPieSlice slice2("foobar", 1.0);
                 QCOMPARE(slice2.value(), 1.0);
                 QCOMPARE(slice2.label(), QString("foobar"));
                 QVERIFY(!slice2.isLabelVisible());
                 QVERIFY(!slice2.isExploded());
                 QCOMPARE(slice2.pen(), QPen());
                 QCOMPARE(slice2.brush(), QBrush());
                 QCOMPARE(slice2.labelPen(), QPen());
                 QCOMPARE(slice2.labelFont(), QFont());
                 QCOMPARE(slice2.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice2.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice2.percentage(), 0.0);
                 QCOMPARE(slice2.startAngle(), 0.0);
                 QCOMPARE(slice2.angleSpan(), 0.0);
             }
             void tst_qpieslice::changedSignals()
             {
                 QPieSlice slice;
                 QSignalSpy valueSpy(&slice, SIGNAL(valueChanged()));
                 QSignalSpy labelSpy(&slice, SIGNAL(labelChanged()));
                 QSignalSpy explodedSpy(&slice, SIGNAL(explodedChanged()));
                 QSignalSpy penSpy(&slice, SIGNAL(penChanged()));
                 QSignalSpy brushSpy(&slice, SIGNAL(brushChanged()));
                 QSignalSpy labelPenSpy(&slice, SIGNAL(labelPenChanged()));
                 QSignalSpy labelFontSpy(&slice, SIGNAL(labelFontChanged()));
                 QSignalSpy labelArmLengthFactorSpy(&slice, SIGNAL(labelArmLengthFactorChanged()));
                 QSignalSpy explodeDistanceFactorSpy(&slice, SIGNAL(explodeDistanceFactorChanged()));
                 // percentageChanged(), startAngleChanged() and angleSpanChanged() signals tested at tst_qpieseries::calculatedValues()
                 // set everything twice to see we do not get unnecessary signals
-                slice.setValue(1);
+                slice.setValue(1.0);
-                slice.setValue(1);
+                slice.setValue(-1.0);
+                QCOMPARE(slice.value(), 1.0);
                 slice.setLabel("foobar");
                 slice.setLabel("foobar");
                 slice.setLabelVisible();
                 slice.setLabelVisible();
                 slice.setExploded();
                 slice.setExploded();
                 slice.setPen(QPen(Qt::red));
                 slice.setPen(QPen(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 TRY_COMPARE(valueSpy.count(), 1);
                 TRY_COMPARE(labelSpy.count(), 1);
                 TRY_COMPARE(explodedSpy.count(), 1);
                 TRY_COMPARE(penSpy.count(), 1);
                 TRY_COMPARE(brushSpy.count(), 1);
                 TRY_COMPARE(labelPenSpy.count(), 1);
                 TRY_COMPARE(labelFontSpy.count(), 1);
                 TRY_COMPARE(labelArmLengthFactorSpy.count(), 1);
                 TRY_COMPARE(explodeDistanceFactorSpy.count(), 1);
             }
             void tst_qpieslice::customize()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // customize a slice
                 QPen p1(Qt::red);
                 s1->setPen(p1);
                 QBrush b1(Qt::red);
                 s1->setBrush(b1);
                 s1->setLabelPen(p1);
                 QFont f1("Consolas");
                 s1->setLabelFont(f1);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //QTest::qWait(1000);
                 // check that customizations persist
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // remove a slice
                 series->remove(s2);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // add a slice
                 series->append("slice 4", 4);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // insert a slice
                 series->insert(0, new QPieSlice("slice 5", 5));
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // change theme
                 // theme will overwrite customizations
                 view.chart()->setTheme(QChart::ChartThemeHighContrast);
                 QVERIFY(s1->pen() != p1);
                 QVERIFY(s1->brush() != b1);
                 QVERIFY(s1->labelPen() != p1);
                 QVERIFY(s1->labelFont() != f1);
             }
             void tst_qpieslice::mouseClick()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 QPieSlice *s3 = series->append("slice 3", 3);
                 QSignalSpy clickSpy1(s1, SIGNAL(clicked()));
                 QSignalSpy clickSpy2(s2, SIGNAL(clicked()));
                 QSignalSpy clickSpy3(s3, SIGNAL(clicked()));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(139, 85)); // inside slice 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(146, 136)); // inside slice 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(91, 119)); // inside slice 3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(70, 70)); // inside pie rectangle but not inside a slice
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(170, 170)); // inside pie rectangle but not inside a slice
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(clickSpy1.count(), 1);
                 QCOMPARE(clickSpy2.count(), 1);
                 QCOMPARE(clickSpy3.count(), 1);
             }
             void tst_qpieslice::mouseHover()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside slice rectangle but NOT the actual slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(s1, SIGNAL(hovered(bool)));
                 QTest::mouseMove(view.viewport(), QPoint(170, 70));
                 TRY_COMPARE(hoverSpy.count(), 0);
                 // move inside the slice
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(0)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(0)), false);
             }
             QTEST_MAIN(tst_qpieslice)
             #include "tst_qpieslice.moc"

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages