HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r683:ef336a9288eb

Fixes after merge

Michal Klocek -

r683:ef336a9288eb

parent child

Context file:

r683:ef336a9288eb

Collapse all files

src/animations/baranimation.cpp 0 -7

             #include "baranimation_p.h"
             #include "barchartitem_p.h"
             #include <QParallelAnimationGroup>
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             //Q_DECLARE_METATYPE(BarLayout)     // TODO?
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarAnimation::BarAnimation(BarChartItem *item)
                 :ChartAnimation(item),
                 m_item(item)
             {
             }
             BarAnimation::~BarAnimation()
             {
             }
-            void BarAnimation::updateValues(const QVector<QRectF>& layout)
-                // TODO?:
-            //    qDebug() << "BarAnimation::updateValues" << layout.count();
             QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
                 QVector<QRectF> startVector = qVariantValue<QVector<QRectF> > (from);
                 QVector<QRectF> endVector = qVariantValue<QVector<QRectF> > (to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count()) ;
                 for(int i =0 ;i< startVector.count();i++){
                     //QRectF value = startVector[i] + ((endVector[i] - startVector[i]) * progress);
                     QPointF topLeft = startVector[i].topLeft() + ((endVector[i].topLeft() - startVector[i].topLeft()) * progress);
                     QSizeF size = startVector[i].size() + ((endVector[i].size() - startVector[i].size()) * progress);
                     QRectF value(topLeft,size);
                     result << value;
                 }
                 return qVariantFromValue(result);
             }
             void BarAnimation::updateCurrentValue(const QVariant &value)
             {
                 QVector<QRectF> layout = qVariantValue<QVector<QRectF> >(value);
                 m_item->setLayout(layout);
             }
             #include "moc_baranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/baranimation_p.h 0 -2

             #ifndef BARANIMATION_P_H_
             #define BARANIMATION_P_H_
             #include "chartanimation_p.h"
             #include "barchartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BarChartItem;
             class QBarSet;
             class BarSetAnimation;
             class BarAnimation : public ChartAnimation
             {
                 Q_OBJECT
             public:
                 BarAnimation(BarChartItem *item);
                 ~BarAnimation();
-                void updateValues(const QVector<QRectF>& layout);
             public: // from QVariantAnimation
                 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
                 virtual void updateCurrentValue (const QVariant & value );
             public Q_SLOTS:
             private:
                 BarChartItem *m_item;
                 QHash<QBarSet*, BarSetAnimation*> m_animations;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/barchartitem.cpp +9 -12

             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 mLayoutSet(false),
                 mSeries(series)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                 connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 initAxisLabels();
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 mBars.clear();
                 mFloatingValues.clear();
                 mLayout.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.append(bar);
                         connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
                         connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
                         connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
                         mLayout.append(QRectF(0,0,0,0));
                     }
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->categoryCount(); category++) {
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
                         connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
                     }
                 }
             }
             /*
             void BarChartItem::layoutChanged()
             {
                 qDebug() << "Deprecated BarChartItem::layoutChanged called. aborting";
                 return;
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarChartitem::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal categoryCount = mSeries->categoryCount();
                 qreal setCount = mSeries->barsetCount();
                 qreal max = mSeries->max();
                 // Domain:
                    if (mDomainMaxY > max) {
                        max = mDomainMaxY;
                    }
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal scale = (height/max);
                 qreal categoryWidth = width/categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 BarLayout layout;
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category  + barWidth/2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         QRectF rect(xPos,yPos-barHeight,mBarWidth,barHeight);
                         layout.insert(bar,rect);
                         // TODO: width settable per bar?
                         bar->setRect(xPos, yPos-barHeight,barWidth, barHeight);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
             //            bar->resize(mBarWidth, barHeight);
             //            layout.insert(bar,QSizeF(mBarWidth,barHeight));
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
             //            bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category + categoryWidth/2 + barWidth;
                     qreal yPos = height;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
             //    update();
             }
             */
             QVector<QRectF> BarChartItem::calculateLayout()
             {
             //    layoutChanged();
             /*
                 BarLayout layout;
                 foreach(Bar* bar, mBars) {
                     layout.insert(bar,bar->boundingRect());
                 }
             */
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
-                int categoryCount = mSeries->categoryCount();
+                qreal categoryCount = mSeries->categoryCount();
-                int setCount = mSeries->barsetCount();
+                qreal setCount = mSeries->barsetCount();
-            //    qreal tW = mWidth;
-            //    qreal tH = mHeight;
                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal tM = mSeries->max();
+                qreal max = mSeries->max();
                 // Domain:
-                if (mDomainMaxY > tM) {
+                if (mDomainMaxY > max) {
-                    tM = mDomainMaxY;
+                    max = mDomainMaxY;
                 }
-                qreal scale = (height/tM);
+                qreal scale = (height/max);
-                qreal tC = categoryCount + 1;
+                qreal categoryWidth = width/categoryCount;
-                qreal categoryWidth = width/tC;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
-                    qreal xPos = categoryWidth * category + categoryWidth /2 + barWidth/2;
+                    qreal xPos = categoryWidth * category + barWidth/2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         QRectF rect(xPos,yPos-barHeight,barWidth,barHeight);
                         //layout.insert(bar,rect);
                         layout.append(rect);
                         // TODO: width settable per bar?
             //            bar->resize(mBarWidth, barHeight);
             //            layout.insert(bar,QSizeF(mBarWidth,barHeight));
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
             //            bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
-                    qreal xPos = categoryWidth * category + categoryWidth/2 + barWidth;
+                    qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, mLayout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 mLayout = layout;
                 for (int i=0; i<mBars.count(); i++) {
                     //mBars.at(i)->setSize(layout.at(i).size());
                     //mBars.at(i)->setPos(layout.at(i).topLeft());
                     mBars.at(i)->setRect(layout.at(i));
                 }
                 update();
             }
             void BarChartItem::initAxisLabels()
             {
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 Domain* domain = presenter()->dataSet()->domain(mSeries);
                 qreal min = 0;
                 qreal max = count+1;
                 domain->setRangeX(min,max,count+1);
             }
             //handlers
             void BarChartItem::handleModelChanged(int index)
             {
                 Q_UNUSED(index)
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 mDomainMinX = minX;
                 mDomainMaxX = maxX;
                 mDomainMinY = minY;
                 mDomainMaxY = maxY;
                 handleLayoutChanged();
                 /*
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 // Position labels to domain
                 qreal min = domain.minX();
                 qreal max = domain.maxX();
                 qreal step = (max-min)/count;
                 QChartAxisCategories& categories = mChart->axisX()->categories();
                 categories.clear();
                 for (int i=0; i<count; i++) {
                     categories.insert(min,mSeries->categoryName(i));
                     min += step;
                 }
                 */
             }
             void BarChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect=rect;
                 handleLayoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarChartItem::handleLayoutChanged()
             {
                 qDebug() << "BarChartItem::handleLayoutChanged";
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain_p.h +2 -2

             #ifndef DOMAIN_H_
             #define DOMAIN_H_
             #include "qchartglobal.h"
             #include "qchartaxis.h"
             #include <QRectF>
             #include <QSizeF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain: public QObject {
                 Q_OBJECT
             public:
                 explicit Domain(QObject* object=0);
                 virtual ~Domain();
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY, int tickXCount, int tickYCount);
                 void setRangeX(qreal min, qreal max);
                 void setRangeX(qreal min, qreal max, int tickCount);
                 void setRangeY(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max, int tickCount);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const {return m_minX;};
                 qreal maxX() const {return m_maxX;};
                 qreal minY() const {return m_minY;};
                 qreal maxY() const {return m_maxY;};
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
                 int tickXCount() const {return m_tickXCount;}
                 int tickYCount() const {return m_tickYCount;}
                 friend bool operator== (const Domain &domain1, const Domain &domain2);
                 friend bool operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug operator<<(QDebug dbg, const Domain &domain);
                 void zoomIn(const QRectF& rect, const QSizeF& size);
                 void zoomOut(const QRectF& rect, const QSizeF& size);
                 void move(int dx,int dy,const QSizeF& size);
             signals:
                 void domainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void rangeXChanged(qreal min, qreal max, int tickXCount);
                 void rangeYChanged(qreal min, qreal max, int tickYCount);
             public slots:
-                void handleAxisXChanged(qreal min,qreal max,int tickXCount,QChartAxis::LabelsSelection mode);
+                void handleAxisXChanged(qreal min,qreal max,int tickXCount = 5,QChartAxis::LabelsSelection mode = QChartAxis::NativeLabelsSelection);
-                void handleAxisYChanged(qreal min,qreal max,int tickYCount,QChartAxis::LabelsSelection mode);
+                void handleAxisYChanged(qreal min,qreal max,int tickYCount = 5,QChartAxis::LabelsSelection mode = QChartAxis::NativeLabelsSelection);
             private:
                 void niceNumbers(qreal &min, qreal &max, int &ticksCount);
                 void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 qreal niceNumber(qreal x,bool celing);
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 int m_tickXCount;
                 int m_tickYCount;
                 QChartAxis::LabelsSelection m_selection;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/auto/domain/tst_domain.cpp +3 -2

             #include <QtTest/QtTest>
             #include <private/domain_p.h>
+            #include <qchartaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain*)
             Q_DECLARE_METATYPE(QSizeF)
             class tst_Domain : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void domain();
                 void handleAxisRangeXChanged_data();
                 void handleAxisRangeXChanged();
                 void handleAxisRangeYChanged_data();
                 void handleAxisRangeYChanged();
                 void isEmpty_data();
                 void isEmpty();
                 void maxX_data();
                 void maxX();
                 void maxY_data();
                 void maxY();
                 void minX_data();
                 void minX();
                 void minY_data();
                 void minY();
                 void operatorEquals_data();
                 void operatorEquals();
                 void setRange_data();
                 void setRange();
                 void setRangeX_data();
                 void setRangeX();
                 void setRangeY_data();
                 void setRangeY();
                 void spanX_data();
                 void spanX();
                 void spanY_data();
                 void spanY();
                 void zoom_data();
                 void zoom();
             };
             void tst_Domain::initTestCase()
             {
             }
             void tst_Domain::cleanupTestCase()
             {
             }
             void tst_Domain::init()
             {
             }
             void tst_Domain::cleanup()
             {
             }
             void tst_Domain::domain()
             {
                 Domain domain;
                 QCOMPARE(domain.isEmpty(), true);
                 QCOMPARE(domain.maxX(), 0.0);
                 QCOMPARE(domain.maxY(), 0.0);
                 QCOMPARE(domain.minX(), 0.0);
                 QCOMPARE(domain.minY(), 0.0);
             }
             void tst_Domain::handleAxisRangeXChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisRangeXChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
-                domain.handleAxisRangeXChanged(min, max);
+                domain.handleAxisXChanged(min, max);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(arg0.at(0).toReal() == min);
                 QVERIFY(arg0.at(1).toReal() == max);
                 QList<QVariant> arg1 = spy1.first();
                 QVERIFY(arg1.at(0).toReal() == min);
                 QVERIFY(arg1.at(1).toReal() == max);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::handleAxisRangeYChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisRangeYChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
-                domain.handleAxisRangeYChanged(min, max);
+                domain.handleAxisYChanged(min, max,5);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(arg0.at(2).toReal() == min);
                 QVERIFY(arg0.at(3).toReal() == max);
                 QList<QVariant> arg1 = spy2.first();
                 QVERIFY(arg1.at(0).toReal() == min);
                 QVERIFY(arg1.at(1).toReal() == max);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::isEmpty_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::addColumn<bool>("isEmpty");
                 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
             }
             void tst_Domain::isEmpty()
             {
             	QFETCH(qreal, minX);
             	QFETCH(qreal, maxX);
             	QFETCH(qreal, minY);
             	QFETCH(qreal, maxY);
                 QFETCH(bool, isEmpty);
                 Domain domain;
                 domain.setRange(minX,maxX,minY,maxY);
                 QCOMPARE(domain.isEmpty(), isEmpty);
             }
             void tst_Domain::maxX_data()
             {
                 QTest::addColumn<qreal>("maxX1");
                 QTest::addColumn<qreal>("maxX2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxX()
             {
                 QFETCH(qreal, maxX1);
                 QFETCH(qreal, maxX2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
                 domain.setMaxX(maxX1);
                 QCOMPARE(domain.maxX(), maxX1);
                 domain.setMaxX(maxX2);
                 QCOMPARE(domain.maxX(), maxX2);
                 QCOMPARE(spy0.count(), count);
                 QCOMPARE(spy1.count(), count);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::maxY_data()
             {
             	QTest::addColumn<qreal>("maxY1");
             	QTest::addColumn<qreal>("maxY2");
             	QTest::addColumn<int>("count");
             	QTest::newRow("1") << 0.0 << 1.0 << 1;
             	QTest::newRow("1.0") << 1.0 << 1.0 << 1;
             	QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxY()
             {
             	QFETCH(qreal, maxY1);
             	QFETCH(qreal, maxY2);
             	QFETCH(int, count);
             	Domain domain;
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	domain.setMaxY(maxY1);
             	QCOMPARE(domain.maxY(), maxY1);
             	domain.setMaxY(maxY2);
             	QCOMPARE(domain.maxY(), maxY2);
             	QCOMPARE(spy0.count(), count);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), count);
             }
             void tst_Domain::minX_data()
             {
             	QTest::addColumn<qreal>("minX1");
             	QTest::addColumn<qreal>("minX2");
             	QTest::addColumn<int>("count");
             	QTest::newRow("1") << 0.0 << 1.0 << 1;
             	QTest::newRow("1.0") << 1.0 << 1.0 << 1;
             	QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minX()
             {
             	QFETCH(qreal, minX1);
             	QFETCH(qreal, minX2);
             	QFETCH(int, count);
             	Domain domain;
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	domain.setMinX(minX1);
             	QCOMPARE(domain.minX(), minX1);
             	domain.setMinX(minX2);
             	QCOMPARE(domain.minX(), minX2);
             	QCOMPARE(spy0.count(), count);
             	QCOMPARE(spy1.count(), count);
             	QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::minY_data()
             {
             	QTest::addColumn<qreal>("minY1");
             	QTest::addColumn<qreal>("minY2");
             	QTest::addColumn<int>("count");
             	QTest::newRow("1") << 0.0 << 1.0 << 1;
             	QTest::newRow("1.0") << 1.0 << 1.0 << 1;
             	QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minY()
             {
             	QFETCH(qreal, minY1);
             	QFETCH(qreal, minY2);
             	QFETCH(int, count);
             	Domain domain;
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	domain.setMinY(minY1);
             	QCOMPARE(domain.minY(), minY1);
             	domain.setMinY(minY2);
             	QCOMPARE(domain.minY(), minY2);
             	QCOMPARE(spy0.count(), count);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), count);
             }
             void tst_Domain::operatorEquals_data()
             {
                 QTest::addColumn<Domain*>("domain1");
                 QTest::addColumn<Domain*>("domain2");
                 QTest::addColumn<bool>("equals");
                 QTest::addColumn<bool>("notEquals");
                 Domain* a;
                 Domain* b;
                 a = new Domain();
                 a->setRange(0,100,0,100);
                 b = new Domain();
                 b->setRange(0,100,0,100);
                 QTest::newRow("equals") << a << b << true <<false;
                 a = new Domain();
                 a->setRange(0,100,0,100);
                 b = new Domain();
                 b->setRange(0,100,0,1);
                 QTest::newRow("equals") << a << b << false << true;
                 a = new Domain();
                 a->setRange(0,100,0,100);
                 b = new Domain();
                 b->setRange(0,1,0,100);
                 QTest::newRow("equals") << a << b << false << true;
             }
             void tst_Domain::operatorEquals()
             {
                 QFETCH(Domain*, domain1);
                 QFETCH(Domain*, domain2);
                 QFETCH(bool, equals);
                 QFETCH(bool, notEquals);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
                 QCOMPARE(*domain1==*domain2, equals);
                 QCOMPARE(*domain1!=*domain2, notEquals);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRange_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
                 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
                 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
             }
             void tst_Domain::setRange()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
                 domain.setRange(minX, maxX, minY, maxY);
                 QCOMPARE(domain.minX(), minX);
                 QCOMPARE(domain.maxX(), maxX);
                 QCOMPARE(domain.minY(), minY);
                 QCOMPARE(domain.maxY(), maxY);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::setRangeX_data()
             {
             	 QTest::addColumn<qreal>("min");
             	 QTest::addColumn<qreal>("max");
             	 QTest::newRow("-1 1") << -1.0 << 1.0;
             	 QTest::newRow("0 1") << 0.0 << 1.0;
             	 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeX()
             {
             	QFETCH(qreal, min);
             	QFETCH(qreal, max);
             	Domain domain;
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	domain.setRangeX(min, max);
             	QList<QVariant> arg0 = spy0.first();
             	QVERIFY(arg0.at(0).toReal() == min);
             	QVERIFY(arg0.at(1).toReal() == max);
             	QList<QVariant> arg1 = spy1.first();
             	QVERIFY(arg1.at(0).toReal() == min);
             	QVERIFY(arg1.at(1).toReal() == max);
             	QCOMPARE(spy0.count(), 1);
             	QCOMPARE(spy1.count(), 1);
             	QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRangeY_data()
             {
             	QTest::addColumn<qreal>("min");
             	QTest::addColumn<qreal>("max");
             	QTest::newRow("-1 1") << -1.0 << 1.0;
             	QTest::newRow("0 1") << 0.0 << 1.0;
             	QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeY()
             {
             	QFETCH(qreal, min);
             	QFETCH(qreal, max);
             	Domain domain;
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	domain.setRangeY(min, max);
             	QList<QVariant> arg0 = spy0.first();
             	QVERIFY(arg0.at(2).toReal() == min);
             	QVERIFY(arg0.at(3).toReal() == max);
             	QList<QVariant> arg1 = spy2.first();
             	QVERIFY(arg1.at(0).toReal() == min);
             	QVERIFY(arg1.at(1).toReal() == max);
             	QCOMPARE(spy0.count(), 1);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::spanX_data()
             {
             	QTest::addColumn<qreal>("minX");
             	QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("spanX");
                 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
                 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanX()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, spanX);
                 Domain domain;
                 domain.setRangeX(minX,maxX);
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
                 QCOMPARE(domain.spanX(), spanX);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::spanY_data()
             {
             	QTest::addColumn<qreal>("minY");
             	QTest::addColumn<qreal>("maxY");
             	QTest::addColumn<qreal>("spanY");
             	QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
             	QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanY()
             {
             	QFETCH(qreal, minY);
             	QFETCH(qreal, maxY);
             	QFETCH(qreal, spanY);
             	Domain domain;
             	domain.setRangeY(minY,maxY);
             	QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
             	QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
             	QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
             	QCOMPARE(domain.spanY(), spanY);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::zoom_data()
             {
                 QTest::addColumn<QRectF>("rect0");
                 QTest::addColumn<QSizeF>("size0");
                 QTest::addColumn<QRectF>("rect1");
                 QTest::addColumn<QSizeF>("size1");
                 QTest::addColumn<QRectF>("rect2");
                 QTest::addColumn<QSizeF>("size2");
                 QTest::newRow("first") << QRectF(10,10,100,100) << QSizeF(1000,1000) << QRectF(20,20,100,100) << QSizeF(1000,1000) << QRectF(50,50,100,100) << QSizeF(1000,1000);
                 QTest::newRow("scound") << QRectF(10,10,50,50) << QSizeF(1000,1000) << QRectF(20,20,100,100) << QSizeF(1000,1000) << QRectF(50,50,100,100) << QSizeF(1000,1000);
                 QTest::newRow("third") << QRectF(10,10,10,10) << QSizeF(100,100) << QRectF(20,20,20,20) << QSizeF(100,100) << QRectF(50,50,50,50) << QSizeF(100,100);
             }
             void tst_Domain::zoom()
             {
                 QFETCH(QRectF, rect0);
                 QFETCH(QSizeF, size0);
                 QFETCH(QRectF, rect1);
                 QFETCH(QSizeF, size1);
                 QFETCH(QRectF, rect2);
                 QFETCH(QSizeF, size2);
                 Domain domain;
                 domain.setRange(0,1000,0,1000);
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal)));
                 Domain domain0;
                 domain0.setRange(domain.minX(),domain.maxX(),domain.minY(),domain.maxY());
                 domain.zoomIn(rect0, size0);
                 Domain domain1;
                 domain1.setRange(domain.minX(),domain.maxX(),domain.minY(),domain.maxY());
                 domain.zoomIn(rect1, size1);
                 Domain domain2;
                 domain2.setRange(domain.minX(),domain.maxX(),domain.minY(),domain.maxY());
                 domain.zoomIn(rect2, size2);
                 domain.zoomOut(rect2, size2);
                 QCOMPARE(domain == domain2,true);
                 domain.zoomOut(rect1, size1);
                 QCOMPARE(domain == domain1,true);
                 domain.zoomOut(rect0, size0);
                 QCOMPARE(domain == domain0,true);
                 QCOMPARE(spy0.count(), 6);
                 QCOMPARE(spy1.count(), 6);
                 QCOMPARE(spy2.count(), 6);
             }
             QTEST_MAIN(tst_Domain)
             #include "tst_domain.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