HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r416:b3ab09e85735

Merge branch 'master' of https://git.it.local/repos/QtCommercialDevel-13049/charts

Marek Rosa -

r416:b3ab09e85735

parent child

Context file:

r416:b3ab09e85735

Expand all files

example/piechartdrilldown/main.cpp created 644 +113 0

@@ -0,0 +1,113
	1	#include <QtGui/QApplication>
	2	#include <QMainWindow>
	3	#include <qchartglobal.h>
	4	#include <qchartview.h>
	5	#include <qpieseries.h>
	6	#include <qpieslice.h>
	7	#include <QTime>
	8
	9	QTCOMMERCIALCHART_USE_NAMESPACE
	10
	11	class DrilldownSlice : public QPieSlice
	12	{
	13	Q_OBJECT
	14
	15	public:
	16	DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
	17	:m_drilldownSeries(drilldownSeries),
	18	m_prefix(prefix)
	19	{
	20	setValue(value);
	21	setLabelVisible(true);
	22	updateLabel();
	23	connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
	24	}
	25
	26	QSeries* drilldownSeries() const { return m_drilldownSeries; }
	27
	28	public Q_SLOTS:
	29	void updateLabel()
	30	{
	31	QString label = m_prefix;
	32	label += " " + QString::number(this->value())+ "e (";
	33	label += QString::number(this->percentage()*100, 'f', 1) + "%)";
	34	setLabel(label);
	35	}
	36
	37	private:
	38	QSeries* m_drilldownSeries;
	39	QString m_prefix;
	40	};
	41
	42	class DrilldownChart : public QChartView
	43	{
	44	Q_OBJECT
	45	public:
	46	explicit DrilldownChart(QWidget *parent = 0):QChartView(parent), m_currentSeries(0) {}
	47
	48	void changeSeries(QSeries* series)
	49	{
	50	if (m_currentSeries)
	51	removeSeries(m_currentSeries);
	52	m_currentSeries = series;
	53	addSeries(series);
	54	setChartTitle(series->title());
	55	}
	56
	57	public Q_SLOTS:
	58	void handleSliceClicked(QPieSlice* slice)
	59	{
	60	DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
	61	changeSeries(drilldownSlice->drilldownSeries());
	62	}
	63
	64	private:
	65	QSeries* m_currentSeries;
	66	};
	67
	68	int main(int argc, char *argv[])
	69	{
	70	QApplication a(argc, argv);
	71
	72	qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
	73
	74	QMainWindow window;
	75
	76	DrilldownChart* drilldownChart = new DrilldownChart(&window);
	77	drilldownChart->setRenderHint(QPainter::Antialiasing);
	78	drilldownChart->setChartTheme(QChart::ChartThemeVanilla);
	79
	80	QPieSeries* yearSeries = new QPieSeries(drilldownChart);
	81	yearSeries->setTitle("Sales by year - All");
	82	yearSeries->setHoverHighlighting();
	83
	84	QList<QString> months;
	85	months << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
	86	QList<QString> names;
	87	names << "Jane" << "John" << "Axel" << "Mary" << "Samantha" << "Bob";
	88
	89	foreach (QString name, names) {
	90	QPieSeries* series = new QPieSeries(drilldownChart);
	91	series->setTitle("Sales by month - " + name);
	92	series->setHoverHighlighting();
	93
	94	foreach (QString month, months)
	95	*series << new DrilldownSlice(qrand() % 1000, month, yearSeries);
	96
	97	QObject::connect(series, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	98
	99	*yearSeries << new DrilldownSlice(series->total(), name, series);
	100	}
	101
	102	QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	103
	104	drilldownChart->changeSeries(yearSeries);
	105
	106	window.setCentralWidget(drilldownChart);
	107	window.resize(600, 600);
	108	window.show();
	109
	110	return a.exec();
	111	}
	112
	113	#include "main.moc"

example/piechartdrilldown/piechartdrilldown.pro created 644 +9 0

@@ -0,0 +1,9
	1	!include( ../example.pri ) {
	2	error( "Couldn't find the example.pri file!" )
	3	}
	4	TARGET = piechartdrilldown
	5	SOURCES += main.cpp
	6	HEADERS +=
	7
	8
	9	MOC_DIR = $$PWD/moc

src/barchart/barcategory.cpp created 644 +17 0

@@ -0,0 +1,17
	1	#include "barcategory_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4	BarCategory::BarCategory(QString name, QObject *parent) :
	5	QObject(parent)
	6	,mName(name)
	7	{
	8	}
	9
	10	void BarCategory::barRightClickEvent()
	11	{
	12	// TODO:
	13	emit rightClicked(mName);
	14	}
	15
	16	#include "moc_barcategory_p.cpp"
	17	QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barcategory_p.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef BARCATEGORY_P_H
	2	#define BARCATEGORY_P_H
	3
	4	#include <QObject>
	5	#include <qchartglobal.h>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8	// Event handler for bar category
	9	class BarCategory : public QObject
	10	{
	11	Q_OBJECT
	12	public:
	13	explicit BarCategory(QString name, QObject *parent = 0);
	14
	15	signals:
	16	void rightClicked(QString name); // "We want something to happen that involves this category"
	17
	18	public slots:
	19	void barRightClickEvent();
	20
	21	private:
	22	QString mName;
	23	};
	24
	25	QTCOMMERCIALCHART_END_NAMESPACE
	26	#endif // BARCATEGORY_P_H

example/example.pro +1 0

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
+                       piechartdrilldown \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
                        chartview \
                        scatterinteractions

src/barchart/bar.cpp +7 -3

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QGraphicsItem *parent)
                 : QGraphicsObject(parent)
             {
-                setAcceptedMouseButtons(Qt::LeftButton);
+                setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Bar::resize( qreal w, qreal h )
             {
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Bar::setPen(QPen pen)
             {
                 mPen = pen;
             }
             void Bar::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (0 == mHeight) {
                     return;
                 }
                 painter->setBrush(mBrush);
                 // This compensates for rounding errors. drawRect takes ints and cumulative error of pos + size may be over 1.
                 int x0 = mXpos;
                 int x1 = (mXpos + mWidth);
                 int w = x1-x0;
                 int y0 = mYpos;
                 int y1 = (mYpos + mHeight);
                 int h = y1-y0;
                 painter->drawRect(x0, y0 ,w ,h);
             }
             QRectF Bar::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mWidth, mHeight);
                 return r;
             }
-            void Bar::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
+            void Bar::mousePressEvent(QGraphicsSceneMouseEvent* event)
             {
-                emit clicked();
+                if (event->button() == Qt::LeftButton) {
+                    emit clicked();
+                } else if (event->button() == Qt::RightButton) {
+                    emit rightClicked();
+                }
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
             {
                 emit hoverEntered(event->lastScreenPos());
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeaved();
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar_p.h +1 -1

             #ifndef BAR_H
             #define BAR_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Single visual bar item of chart
             class Bar : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 Bar(QGraphicsItem *parent=0);
             public: // from ChartItem
                 void setSize(const QSizeF &size);
                 // Layout Stuff
                 void resize(qreal w, qreal h);
                 void setPos(qreal x, qreal y);
                 void setPen(QPen pen);
                 void setBrush(QBrush brush);
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             Q_SIGNALS:
                 void clicked();
+                void rightClicked();
                 void hoverEntered(QPoint pos);
                 void hoverLeaved();
             private:
                 qreal mHeight;
                 qreal mWidth;
                 qreal mXpos;
                 qreal mYpos;
-                QColor mColor;
                 QBrush mBrush;
                 QPen mPen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BAR_H

src/barchart/barchart.pri +4 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/bar.cpp \
                 $$PWD/barchartmodel.cpp \
                 $$PWD/barlabel.cpp \
                 $$PWD/barpresenter.cpp \
                 $$PWD/barpresenterbase.cpp \
                 $$PWD/percentbarpresenter.cpp \
                 $$PWD/qbarseries.cpp \
                 $$PWD/qbarset.cpp \
                 $$PWD/qpercentbarseries.cpp \
                 $$PWD/qstackedbarseries.cpp \
                 $$PWD/separator.cpp \
                 $$PWD/stackedbarpresenter.cpp \
-                $$PWD/barvalue.cpp
+                $$PWD/barvalue.cpp \
+                $$PWD/barcategory.cpp
             PRIVATE_HEADERS += \
                 $$PWD/bar_p.h \
                 $$PWD/barchartmodel_p.h \
                 $$PWD/barlabel_p.h \
                 $$PWD/barpresenter_p.h \
                 $$PWD/barpresenterbase_p.h \
                 $$PWD/percentbarpresenter_p.h \
                 $$PWD/separator_p.h \
                 $$PWD/stackedbarpresenter_p.h \
-                $$PWD/barvalue_p.h
+                $$PWD/barvalue_p.h \
+                $$PWD/barcategory_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qbarseries.h \
                 $$PWD/qbarset.h \
                 $$PWD/qpercentbarseries.h \
                 $$PWD/qstackedbarseries.h

src/barchart/barchartmodel.cpp +11 -1

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
+            #include "barcategory_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartModel::BarChartModel(QStringList categories, QObject *parent) :
                 QObject(parent)
                 ,mCategory(categories)
             {
+                for (int i=0; i<mCategory.count(); i++) {
+                    BarCategory* cat = new BarCategory(mCategory.at(i), this);
+                    mCategoryObjects.append(cat);
+                }
             }
             QStringList BarChartModel::category()
             {
                 return mCategory;
             }
             void BarChartModel::addBarSet(QBarSet *set)
             {
                 mDataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
                 if (mDataModel.contains(set)) {
                     mDataModel.removeOne(set);
                 }
             }
             QBarSet* BarChartModel::setAt(int index)
             {
                 return mDataModel.at(index);
             }
             QList<QBarSet*> BarChartModel::barSets()
             {
                 return mDataModel;
             }
             QList<QSeries::Legend> BarChartModel::legend()
             {
                 QList<QSeries::Legend> legend;
                 for (int i=0; i<mDataModel.count(); i++) {
                     QSeries::Legend l;
                     l.mName = mDataModel.at(i)->name();
                     l.mPen = mDataModel.at(i)->pen();
                     legend.append(l);
                 }
                 return legend;
             }
             int BarChartModel::barsetCount()
             {
                 return mDataModel.count();
             }
             int BarChartModel::categoryCount()
             {
                 return mCategory.count();
             }
             qreal BarChartModel::min()
             {
                 Q_ASSERT(mDataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal min = INT_MAX;
                 for (int i=0; i <mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp < min) {
                             min = temp;
                         }
                     }
                 }
                 return min;
             }
             qreal BarChartModel::max()
             {
                 Q_ASSERT(mDataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal max = INT_MIN;
                 for (int i=0; i <mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp > max) {
                             max = temp;
                         }
                     }
                 }
                 return max;
             }
             qreal BarChartModel::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return mDataModel.at(set)->valueAt(category);
             }
             qreal BarChartModel::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = mDataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
                 if (0 == total) {
                     return 100.0;
                 }
                 return value / total;
             }
             qreal BarChartModel::categorySum(int category)
             {
                 qreal sum(0);
                 int count = mDataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < mDataModel.at(set)->count()) {
                         sum += mDataModel.at(set)->valueAt(category);
                     }
                 }
                 return sum;
             }
             qreal BarChartModel::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int col=0; col<count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max) {
                         max = sum;
                     }
                 }
                 return max;
             }
-            QString BarChartModel::label(int category)
+            QString BarChartModel::categoryName(int category)
             {
                 return mCategory.at(category);
             }
+            BarCategory* BarChartModel::categoryObject(int category)
+            {
+                return mCategoryObjects.at(category);
+            }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +4 -1

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include <QStringList>
             #include "qchartglobal.h"
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
+            class BarCategory;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QStringList categories, QObject *parent = 0);
                 QStringList category();
                 void addBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 QBarSet *setAt(int index);
                 QList<QBarSet*> barSets();
                 QList<QSeries::Legend> legend();
                 int barsetCount();          // Number of sets in model
                 int categoryCount();        // Number of categories
                 qreal max();                // Maximum value of all sets
                 qreal min();                // Minimum value of all sets
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();     // returns maximum sum of sets in all categories.
-                QString label(int category);
+                QString categoryName(int category);
+                BarCategory* categoryObject(int category);
             signals:
                 void modelUpdated();
             public slots:
             private:
                 QList<QBarSet*> mDataModel;
                 QStringList mCategory;
+                QList<BarCategory*> mCategoryObjects;
                 int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barpresenterbase.cpp +8 -5

             #include "barpresenterbase_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
+            #include "barcategory_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(QBarSeries *series, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mSeparatorsEnabled(false)
                 ,mSeries(series)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series,SIGNAL(separatorsEnabled(bool)),this,SLOT(enableSeparators(bool)));
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
                 delete mSeries;
             }
             void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
                     return;
                 }
             //    if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
             //    }
             }
             QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarPresenterBase::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             void BarPresenterBase::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
-                qDebug() << "datachanged";
+            //    qDebug() << "datachanged";
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 mBars.clear();
                 mLabels.clear();
                 mSeparators.clear();
                 mFloatingValues.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
+                    BarCategory *category = mSeries->categoryObject(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(this);
                         childItems().append(bar);
                         mBars.append(bar);
-                        connect(bar,SIGNAL(clicked()),set,SLOT(barClicked()));
+                        connect(bar,SIGNAL(clicked()),set,SLOT(barClickedEvent()));
-                        connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEntered(QPoint)));
+                        connect(bar,SIGNAL(rightClicked()),category,SLOT(barRightClickEvent()));
-                        connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaved()));
+                        connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
+                        connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
                     }
                 }
                 // Create labels
                 int count = mSeries->categoryCount();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
-                    label->set(mSeries->label(i));
+                    label->set(mSeries->categoryName(i));
                     childItems().append(label);
                     mLabels.append(label);
                 }
                 // Create separators
                 count = mSeries->categoryCount() - 1;   // There is one less separator than columns
                 for (int i=0; i<count; i++) {
                     Separator* sep = new Separator(this);
                     sep->setColor(QColor(255,0,0,255));     // TODO: color for separations from theme
                     sep->setVisible(mSeparatorsEnabled);
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // 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()));
                     }
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarPresenterBase::handleDomainChanged(const Domain& domain)
             {
             //    qDebug() << "BarPresenterBase::handleDomainChanged";
                 // TODO: Figure out the use case for this.
                 // Affects the size of visible item, so layout is changed.
             //    layoutChanged();
             }
             void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarPresenterBase::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             void BarPresenterBase::enableSeparators(bool enabled)
             {
                 for (int i=0; i<mSeparators.count(); i++) {
                     mSeparators.at(i)->setVisible(enabled);
                 }
                 mSeparatorsEnabled = enabled;
             }
             #include "moc_barpresenterbase_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +13 -3

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
+            #include "barcategory_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::changed(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QBarSeries::floatingValuesEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::toolTipEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::separatorsEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QStringList categories, QObject *parent)
                 : QSeries(parent)
                 ,mModel(new BarChartModel(categories, this))
             {
+                for (int i=0; i<mModel->categoryCount(); i++) {
+                    BarCategory *categoryObject = mModel->categoryObject(i);
+                    connect(categoryObject, SIGNAL(rightClicked(QString)), this, SIGNAL(categoryRightClicked(QString)));
+                }
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
                 return mModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
                 return mModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 Returns legend of series.
             */
             QList<QSeries::Legend> QBarSeries::legend()
             {
                 return mModel->legend();
             }
             /*!
                 \internal \a category
             */
-            QString QBarSeries::label(int category)
+            QString QBarSeries::categoryName(int category)
             {
-                return mModel->label(category);
+                return mModel->categoryName(category);
             }
             /*!
                 Enables or disables floating values depending on parameter \a enabled.
                 Floating values are bar values, that are displayed on top of each bar.
                 Calling without parameter \a enabled, enables the floating values
             */
             void QBarSeries::setFloatingValuesEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(clicked()),set,SIGNAL(toggleFloatingValues()));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(clicked()),set,SIGNAL(toggleFloatingValues()));
                     }
                 }
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsEnabled(bool enabled)
             {
                 emit separatorsEnabled(enabled);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
+            BarCategory* QBarSeries::categoryObject(int category)
+            {
+                return mModel->categoryObject(category);
+            }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +5 -2

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include "qseries.h"
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BarChartModel;
+            class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
                 QList<QSeries::Legend> legend();
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
-                QBarSet *barsetAt(int index);
+                QBarSet* barsetAt(int index);
-                QString label(int category);
+                QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
+                BarCategory* categoryObject(int category);
                 // <--- TO PIMPL
             signals:
                 void changed(int index);
+                void categoryRightClicked(QString category);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void floatingValuesEnabled(bool enabled);
                 void toolTipEnabled(bool enabled);
                 void separatorsEnabled(bool enabled);
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setFloatingValuesEnabled(bool enabled=true);    // enables floating values on top of bars
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 void setSeparatorsEnabled(bool enabled=true);        // enables separators between categories
             protected:
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +3 -8

             #include "qbarset.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked()
                 \brief signals that set has been clicked
             */
             /*!
                 \fn void QBarSet::hoverEnter(QPoint pos)
                 \brief signals that mouse has entered over the set at position \a pos.
             */
             /*!
                 \fn void QBarSet::hoverLeave()
                 \brief signals that mouse has left from the set.
             */
             /*!
                 \fn void QBarSet::toggleFloatingValues()
                 \brief \internal
             */
             /*!
                 \fn void QBarSet::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
                 ,mName(name)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name()
             {
                 return mName;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count()
             {
                 return mValues.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
                 mValues.replace(index,value);
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(QPen pen)
             {
                 mPen = pen;
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen()
             {
                 return mPen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush()
             {
                 return mBrush;
             }
             /*!
                 \internal
             */
-            void QBarSet::barClicked()
+            void QBarSet::barClickedEvent()
             {
-            //    qDebug() << "QBarset::barClicked" << this;
                 // Some bar of this set has been clicked
                 // TODO: What happens then?
                 emit clicked();     // Notify that set has been clicked
             }
             /*!
                 \internal \a pos
             */
-            void QBarSet::barHoverEntered(QPoint pos)
+            void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, mName);
                 emit hoverEnter(pos);
             }
             /*!
                 \internal
             */
-            void QBarSet::barHoverLeaved()
+            void QBarSet::barHoverLeaveEvent()
             {
-            //    qDebug() << "QBarset::barHoverLeaved" << this;
-            //    if (mToolTipEnabled) {
-                    // TODO: do what?
-            //    }
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +3 -3

             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
             public:
                 QBarSet(QString name, QObject *parent = 0);
                 void setName(QString name);
                 QString name();
                 QBarSet& operator << (const qreal &value);  // appends new value to set
                 int count();                                // count of values in set
                 qreal valueAt(int index);                   // for modifying individual values
                 void setValue(int index, qreal value);      // setter for individual value
                 void setPen(QPen pen);
                 QPen pen();
                 void setBrush(QBrush brush);
                 QBrush brush();
             Q_SIGNALS:
                 void clicked();                         // Clicked and hover signals exposed to user
                 void hoverEnter(QPoint pos);
                 void hoverLeave();
                 // TODO: Expose this to user or not?
                 // TODO: TO PIMPL --->
                 void toggleFloatingValues();
                 void showToolTip(QPoint pos, QString tip);  // Private signal
                 // <--- TO PIMPL
             public Q_SLOTS:
                 // These are for internal communication
                 // TODO: TO PIMPL --->
-                void barClicked();
+                void barClickedEvent();
-                void barHoverEntered(QPoint pos);
+                void barHoverEnterEvent(QPoint pos);
-                void barHoverLeaved();
+                void barHoverLeaveEvent();
                 // <--- TO PIMPL
             private:
                 QString mName;
                 QList<qreal> mValues;
                 QPen mPen;
                 QBrush mBrush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/chartdataset.cpp +27 -2

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_domainIndex(0),
             m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
             	int i = m_domainMap.count(axisY);
             	if(i == 0){
             		return Domain();
             	}
             	i = i - m_domainIndex -1;
                 return m_domainMap.values(axisY).at(i);
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this); // take ownership
                 clearDomains();
                 if(axisY==0) axisY = m_axisY;
                 axisY->setParent(this); // take ownership
                 QList<QSeries*>  seriesList = m_seriesMap.values(axisY);
                 QList<Domain> domainList = m_domainMap.values(axisY);
                 Q_ASSERT(domainList.size()<=1);
                 Domain domain;
                 if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* xyseries = static_cast<QLineSeries*>(series);
                         for (int i = 0; i < xyseries->count(); i++)
                         {
                             qreal x = xyseries->x(i);
                             qreal y = xyseries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                     qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                     qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                     qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain.m_minX = qMin(domain.m_minX, point.x());
                             domain.m_maxX = qMax(domain.m_maxX, point.x());
                             domain.m_minY = qMin(domain.m_minY, point.y());
                             domain.m_maxY = qMax(domain.m_maxY, point.y());
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 if(!m_domainMap.contains(axisY))
                 {
                     emit axisAdded(axisY);
                     QObject::connect(axisY,SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                 }
                 if(!m_axisXInitialized)
                 {
                     emit axisAdded(axisX());
                     QObject::connect(axisX(),SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                     m_axisXInitialized=true;
                 }
                 m_domainMap.replace(axisY,domain);
                 m_seriesMap.insert(axisY,series);
                 emit seriesAdded(series);
-                setDomain(m_domainIndex);
+                setDomain(m_domainIndex,axisY);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         emit seriesRemoved(series);
                         m_seriesMap.remove(axis,series);
                         //remove axis if no longer there
                         if(!m_seriesMap.contains(axis)){
                             emit axisRemoved(axis);
                             m_domainMap.remove(axis);
                             if(axis != m_axisY)
                             delete axis;
                         }
                         series->setParent(0);
                         break;
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     for(int i =0 ; i < seriesList.size();i++ )
                     {
                         emit seriesRemoved(seriesList.at(i));
                         delete(seriesList.at(i));
                     }
                     m_seriesMap.remove(axis);
                     m_domainMap.remove(axis);
                     emit axisRemoved(axis);
                     if(axis != m_axisY) delete axis;
                     }
                 m_domainIndex=0;
             }
             bool ChartDataSet::nextDomain()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 if(domainList.count()==0) return;
                 Domain domain;
                 foreach (QChartAxis* axis , domainList) {
                     int i = m_domainMap.count(axis) - index -1;
                     Q_ASSERT(i>=0);
                     domain = m_domainMap.values(axis).at(i);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     axis->updateRange(domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 axisX()->updateRange(domain.m_minX,domain.m_maxY);
                 emit axisRangeChanged(axisX(),labels);
             }
+            void ChartDataSet::setDomain(int index,QChartAxis* axis)
+            {
+                int i = m_domainMap.count(axis) - index -1;
+                Q_ASSERT(i>=0);
+                Domain domain = m_domainMap.values(axis).at(i);
+                {
+                QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
+                QList<QSeries*> seriesList = m_seriesMap.values(axis);
+                foreach(QSeries* series, seriesList) {
+                    emit seriesDomainChanged(series,domain);
+                }
+                axis->updateRange(domain.m_minY,domain.m_maxY);
+                emit axisRangeChanged(axis,labels);
+                }
+                QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
+                axisX()->updateRange(domain.m_minX,domain.m_maxY);
+                emit axisRangeChanged(axisX(),labels);
+            }
             void ChartDataSet::clearDomains(int toIndex)
             {
                 Q_ASSERT(toIndex>=0);
                 m_domainIndex = toIndex;
                 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* key , keys)
                 {
                     QList<Domain> domains = m_domainMap.values(key);
                     m_domainMap.remove(key);
                     int i = domains.size() - toIndex - 1;
                     while(i--){
                         domains.removeFirst();
                     }
                     for(int j=domains.size()-1; j>=0 ;j--)
                         m_domainMap.insert(key,domains.at(j));
                 }
             }
             void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
             {
                 Q_ASSERT(rect.isValid());
                 Q_ASSERT(viewport.isValid());
                 clearDomains(m_domainIndex);
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 Domain domain;
                 foreach (QChartAxis* axis , domainList){
                     domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
                     m_domainMap.insert(axis,domain);
                 }
                 setDomain(++m_domainIndex);
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         return axis;
                     }
                 }
                 return 0;
             }
             QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
             {
                 Q_ASSERT(max>=min);
                 QStringList labels;
                 int ticks = axis->ticksCount()-1;
                 for(int i=0; i<= ticks; i++){
                     qreal value = min + (i * (max - min)/ ticks);
                     QString label = axis->axisTickLabel(value);
                     if(label.isEmpty()){
                         labels << QString::number(value);
                     }else{
                         labels << label;
                     }
                 }
                 return labels;
             }
             void ChartDataSet::handleRangeChanged(QChartAxis* axis)
             {
                 qreal min = axis->min();
                 qreal max = axis->max();
                 if(axis==axisX()) {
                     m_domainIndex=0;
                     clearDomains(m_domainIndex);
                     QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                     foreach (QChartAxis* axis , domainList) {
                         Q_ASSERT(m_domainMap.values(axis).size()==1);
                         Domain domain = m_domainMap.value(axis);
                         domain.m_minX=min;
                         domain.m_maxX=max;
                         m_domainMap.replace(axis,domain);
                     }
+                    setDomain(m_domainIndex);
                 }
                 else {
                     QList<Domain> domains = m_domainMap.values(axis);
                     m_domainMap.remove(axis);
                     for(int i=0;i<domains.size();i++)
                     {
                         domains[i].m_minY=min;
                         domains[i].m_maxY=max;
                     }
                     for(int j=domains.size()-1; j>=0;j--)
                     m_domainMap.insert(axis,domains.at(j));
+                    setDomain(m_domainIndex,axis);
                 }
-                setDomain(m_domainIndex);
             }
             void ChartDataSet::handleTickChanged(QChartAxis* axis)
             {
                 if(axis==axisX()){
                     Domain domain = m_domainMap.value(axisY());
                     QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
                     emit axisRangeChanged(axis,labels);
                 }else{
                     Domain domain = m_domainMap.value(axis);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +1 0

             #ifndef CHARTDATASET_P_H_
             #define CHARTDATASET_P_H_
             #include "qseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QSeries* series,QChartAxis *axisY = 0);
                 void removeSeries(QSeries* series);
                 void removeAllSeries();
                 void addDomain(const QRectF& rect, const QRectF& viewport);
                 bool nextDomain();
                 bool previousDomain();
                 void clearDomains(int toIndex =0);
                 const Domain domain(QChartAxis *axisY) const;
                 int domainIndex() const {return m_domainIndex;}
                 void setDomain(int index);
+                void setDomain(int index,QChartAxis* axis);
                 QChartAxis* axisX() const { return m_axisX;};
                 QChartAxis* axisY(QSeries* series = 0) const;
             signals:
                 void seriesAdded(QSeries* series);
                 void seriesRemoved(QSeries* series);
                 void axisAdded(QChartAxis* axis);
                 void axisRemoved(QChartAxis* axis);
                 void axisRangeChanged(QChartAxis* axis, const QStringList& labels);
                 void seriesDomainChanged(QSeries* series,const Domain& domain);
             private slots:
             	void handleRangeChanged(QChartAxis*);
             	void handleTickChanged(QChartAxis*);
             private:
                 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
             private:
                 QMultiMap<QChartAxis*, Domain> m_domainMap;
                 QMultiMap<QChartAxis*, QSeries*> m_seriesMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/piechart/piepresenter.cpp +12 -2

             #include "piepresenter_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "pieslicelabel_p.h"
             #include "qpieseries.h"
             #include <qmath.h>
             #include <QDebug>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(changed(const QPieSeries::ChangeSet&)), this, SLOT(handleSeriesChanged(const QPieSeries::ChangeSet&)));
                 connect(series, SIGNAL(sizeFactorChanged()), this, SLOT(updateGeometry()));
                 connect(series, SIGNAL(positionChanged()), this, SLOT(updateGeometry()));
                 if (m_series->count()) {
                     QPieSeries::ChangeSet changeSet;
                     changeSet.appendAdded(m_series->m_slices);
                     handleSeriesChanged(changeSet);
                 }
             }
             PiePresenter::~PiePresenter()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PiePresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
             }
             void PiePresenter::handleSeriesChanged(const QPieSeries::ChangeSet& changeSet)
             {
                 //qDebug() << "PiePresenter::handleSeriesChanged()";
                 //qDebug() << "  added  : " << changeSet.added();
                 //qDebug() << "  changed: " << changeSet.changed();
                 //qDebug() << "  removed: " << changeSet.removed();
                 foreach (QPieSlice* s, changeSet.added())
                     addSlice(s);
                 foreach (QPieSlice* s, changeSet.changed())
                     updateSlice(s);
                 foreach (QPieSlice* s, changeSet.removed())
                     deleteSlice(s);
                 // every change possibly changes the actual pie size
                 updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 prepareGeometryChange();
                 updateGeometry();
             }
             void PiePresenter::updateGeometry()
             {
                 if (!m_rect.isValid() || m_rect.isEmpty())
                     return;
                 // calculate maximum rectangle for pie
                 QRectF pieRect = m_rect;
                 if (pieRect.width() < pieRect.height()) {
                     pieRect.setWidth(pieRect.width() * m_series->sizeFactor());
                     pieRect.setHeight(pieRect.width());
                     pieRect.moveCenter(m_rect.center());
                 } else {
                     pieRect.setHeight(pieRect.height() * m_series->sizeFactor());
                     pieRect.setWidth(pieRect.height());
                     pieRect.moveCenter(m_rect.center());
                 }
                 // position the pie rectangle
                 switch (m_series->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 // calculate how much space we need around the pie rectangle (labels & exploding)
                 qreal delta = 0;
                 qreal pieRadius = pieRect.height() / 2;
                 foreach (QPieSlice* s, m_series->m_slices) {
                     // calculate the farthest point in the slice from the pie center
+                    // the arm
                     qreal centerAngle = s->m_startAngle + (s->m_angleSpan / 2);
-                    qreal len = pieRadius + s->labelArmLength() + s->explodeDistance();
+                    qreal len = pieRadius + PIESLICE_LABEL_GAP + s->labelArmLength() + s->explodeDistance();
                     QPointF dp(qSin(centerAngle*(PI/180)) * len, -qCos(centerAngle*(PI/180)) * len);
                     QPointF p = pieRect.center() + dp;
-                    // TODO: consider the label text
+                    // the label text
+                    QFontMetricsF fm(s->labelFont());
+                    QRectF labelRect = fm.boundingRect(s->label());
+                    if (centerAngle < 90 || centerAngle > 270)
+                        p += QPointF(0, -labelRect.height());
+                    if (centerAngle < 180)
+                        p += QPointF(labelRect.width(), 0);
+                    else
+                        p += QPointF(-labelRect.width(), 0);
                     // calculate how much the radius must get smaller to fit that point in the base rectangle
                     qreal dt = m_rect.top() - p.y();
                     if (dt > delta) delta = dt;
                     qreal dl = m_rect.left() - p.x();
                     if (dl > delta) delta = dl;
                     qreal dr = p.x() - m_rect.right();
                     if (dr > delta) delta = dr;
                     qreal db = p.y() - m_rect.bottom();
                     if (db > delta) delta = db;
                     //if (!m_rect.contains(p)) qDebug() << s->label() << dt << dl << dr << db << "delta" << delta;
                 }
                 // shrink the pie rectangle so that everything outside it fits the base rectangle
                 pieRect.adjust(delta, delta, -delta, -delta);
                 // update slices
                 if (m_pieRect != pieRect) {
                     m_pieRect = pieRect;
                     //qDebug() << "PiePresenter::updateGeometry()" << m_rect << m_pieRect;
                     foreach (PieSlice* s, m_slices.values()) {
                         s->setPieRect(m_pieRect);
                         s->updateGeometry();
                         s->update();
                     }
                 }
             }
             void PiePresenter::addSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::addSlice()" << sliceData;
                 if (m_slices.keys().contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 // create slice
                 PieSlice *slice = new PieSlice(this);
                 slice->setPieRect(m_pieRect);
                 slice->updateData(sliceData);
                 slice->updateGeometry();
                 slice->update();
                 m_slices.insert(sliceData, slice);
                 // connect signals
                 connect(slice, SIGNAL(clicked()), sliceData, SIGNAL(clicked()));
                 connect(slice, SIGNAL(hoverEnter()), sliceData, SIGNAL(hoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), sliceData, SIGNAL(hoverLeave()));
             }
             void PiePresenter::updateSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::updateSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 m_slices[sliceData]->updateData(sliceData);
             }
             void PiePresenter::deleteSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::deleteSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 delete m_slices.take(sliceData);
             }
             #include "moc_piepresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.cpp +1 -1

             #include "pieslice_p.h"
             #include "pieslicelabel_p.h"
             #include "piepresenter_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSlice::PieSlice(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_slicelabel(new PieSliceLabel(this)),
                 m_startAngle(0),
                 m_angleSpan(0),
                 m_isExploded(false),
                 m_explodeDistance(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_path.boundingRect();
             }
             QPainterPath PieSlice::shape() const
             {
                 return m_path;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawPath(m_path);
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSlice::setPieRect(QRectF rect)
             {
                 m_pieRect = rect;
             }
             void PieSlice::updateGeometry()
             {
                 if (!m_pieRect.isValid() || m_pieRect.isEmpty())
                     return;
                 prepareGeometryChange();
                 // calculate center angle
                 qreal centerAngle = m_startAngle + (m_angleSpan/2);
                 // adjust rect for exploding
                 QRectF rect = m_pieRect;
                 if (m_isExploded) {
                     qreal dx = qSin(centerAngle*(PI/180)) * m_explodeDistance;
                     qreal dy = -qCos(centerAngle*(PI/180)) * m_explodeDistance;
                     rect.translate(dx, dy);
                 }
                 // update slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -m_startAngle + 90, -m_angleSpan);
                 path.closeSubpath();
                 m_path = path;
                 // update label position
                 qreal radius = rect.height() / 2;
-                QPointF edgeCenter = rect.center() + offset(centerAngle, radius + 5);
+                QPointF edgeCenter = rect.center() + offset(centerAngle, radius + PIESLICE_LABEL_GAP);
                 m_slicelabel->setArmStartPoint(edgeCenter);
                 m_slicelabel->setArmAngle(centerAngle);
                 m_slicelabel->updateGeometry();
                 m_slicelabel->update();
                 //qDebug() << "PieSlice::updateGeometry" << m_slicelabel->text() << boundingRect() << m_angle << m_span;
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
                 m_startAngle = sliceData->startAngle();
                 m_angleSpan = sliceData->m_angleSpan;
                 m_isExploded = sliceData->isExploded();
                 m_explodeDistance = sliceData->explodeDistance(); // TODO: expose to public API
                 m_pen = sliceData->pen();
                 m_brush = sliceData->brush();
                 m_slicelabel->setVisible(sliceData->isLabelVisible());
                 m_slicelabel->setText(sliceData->label());
                 m_slicelabel->setPen(sliceData->labelPen());
                 m_slicelabel->setFont(sliceData->labelFont());
                 m_slicelabel->setArmLength(sliceData->labelArmLength());
                 updateGeometry();
                 update();
             }
             #include "moc_pieslice_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice_p.h +2 0

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
+            #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSliceLabel;
             class QPieSlice;
             class PieSlice : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSlice(QGraphicsItem* parent = 0);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
             public Q_SLOTS:
                 void setPieRect(QRectF rect);
                 void updateGeometry();
                 void updateData(const QPieSlice *sliceData);
             public:
                 PieSliceLabel* label() { return m_slicelabel; }
             private:
                 PieSliceLabel* m_slicelabel;
                 QRectF m_pieRect;
                 QPainterPath m_path;
                 qreal m_startAngle;
                 qreal m_angleSpan;
                 bool m_isExploded;
                 qreal m_explodeDistance;
                 QPen m_pen;
                 QBrush m_brush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/piechart/pieslicelabel.cpp +2 -2

             #include "pieslicelabel_p.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265
             PieSliceLabel::PieSliceLabel(QGraphicsItem* parent)
                 :QGraphicsItem(parent),
                 m_armAngle(0),
                 m_armLength(0)
             {
             }
             void PieSliceLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setPen(m_pen);
                 painter->drawPath(m_armPath);
                 // TODO: do we need a pen for text?
                 painter->setFont(m_font);
                 painter->drawText(m_textRect.bottomLeft(), m_text);
                 //qDebug() << "PieSliceLabel::paint" << m_text << m_textRect;
             }
             void PieSliceLabel::updateGeometry()
             {
                 prepareGeometryChange();
                 // calculate text size
                 QFontMetricsF fm(m_font);
                 QRectF textRect = fm.boundingRect(m_text);
                 // calculate path for arm and text start point
                 qreal dx = qSin(m_armAngle*(PI/180)) * m_armLength;
                 qreal dy = -qCos(m_armAngle*(PI/180)) * m_armLength;
                 QPointF parm1 = m_armStartPoint + QPointF(dx, dy);
                 // calculate horizontal arm and text position
                 QPointF parm2 = parm1;
                 textRect.moveBottomLeft(parm1);
                 if (m_armAngle < 180) { // arm swings the other way on the left side
-                     parm2 += QPointF(m_textRect.width(), 0);
+                     parm2 += QPointF(textRect.width(), 0);
                 } else {
-                     parm2 += QPointF(-m_textRect.width(),0);
+                     parm2 += QPointF(-textRect.width(),0);
                      textRect.moveBottomLeft(parm2);
                 }
                 // add a little offset to text so that it does not touch the arm
                 qreal yOffset = m_pen.widthF() ? m_pen.widthF() : 2;
                 textRect.translate(0, -yOffset);
                 // update arm path
                 QPainterPath path;
                 path.moveTo(m_armStartPoint);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 // update paths & rects
                 m_armPath = path;
                 m_textRect = textRect;
                 m_rect = path.boundingRect().united(m_textRect);
                 //qDebug() << "PieSliceLabel::updateGeometry" << m_text << m_armStartPoint << m_armLength << m_armAngle << m_textRect;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +24 -6

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \enum QPieSeries::PiePosition
                 This enum describes pie position within its bounding rectangle
                 \value PiePositionMaximized
                 \value PiePositionTopLeft
                 \value PiePositionTopRight
                 \value PiePositionBottomLeft
                 \value PiePositionBottomRight
             */
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 To help with the most common user interaction scenarions there some convenience functions.
                 Like exploding a slice when clicked and higlighting when user hovers over a slice.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized),
                 m_pieStartAngle(0),
                 m_pieAngleSpan(360)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                     changeSet.appendAdded(s);
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit changed(changeSet);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
+            /*!
+                Adds a single \a slice to the series and returns a reference to the series.
+                Slice ownership is passed to the series.
+            */
+            QPieSeries& QPieSeries::operator << (QPieSlice* slice)
+            {
+                add(slice);
+                return *this;
+            }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 ChangeSet changeSet;
                 changeSet.appendRemoved(slice);
                 emit changed(changeSet);
                 delete slice;
                 slice = NULL;
                 updateDerivativeData();
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, m_slices) {
                     changeSet.appendRemoved(s);
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the size \a factor of the pie. 1.0 is the default value.
                 Note that the pie will not grow beyond its absolute maximum size.
                 In practice its use is to make the pie appear smaller.
                 \sa sizeFactor()
             */
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor < 0.0)
                     return;
                 if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
                     emit sizeFactorChanged();
                 }
             }
             /*!
                 Gets the size factor of the pie.
                 \sa setSizeFactor()
             */
             qreal QPieSeries::sizeFactor() const
             {
                 return m_sizeFactor;
             }
             /*!
                 Sets the \a position of the pie within its bounding rectangle.
                 \sa PiePosition, position()
             */
             void QPieSeries::setPosition(PiePosition position)
             {
                 if (m_position != position) {
                     m_position = position;
                     emit positionChanged();
                 }
             }
             /*!
                 Gets the position of the pie within its bounding rectangle.
                 \sa PiePosition, setPosition()
             */
             QPieSeries::PiePosition QPieSeries::position() const
             {
                 return m_position;
             }
             /*!
                 Sets the \a startAngle and \a angleSpan of this series.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
             */
             void QPieSeries::setSpan(qreal startAngle, qreal angleSpan)
             {
                 if (startAngle >= 0 && startAngle < 360 &&
                     angleSpan > 0 && angleSpan <= 360) {
                     m_pieStartAngle = startAngle;
                     m_pieAngleSpan = angleSpan;
                     updateDerivativeData();
                 }
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Convenience method for exploding a slice when user clicks the pie. Set \a enable to true to
                 explode slices by clicking.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded(), QPieSlice::setExplodeDistance()
             */
             void QPieSeries::setClickExplodes(bool enable)
             {
                 if (enable)
                     connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
                 else
                     disconnect(this, SLOT(toggleExploded(QPieSlice*)));
             }
             /*!
                 Convenience method for highlighting a slice when user hovers over the slice.
                 It changes the slice color to be lighter and shows the label of the slice.
                 Set \a enable to true to highlight a slice when user hovers on top of it.
-                \sa QPieSlice::isExploded(), QPieSlice::setExploded()
             */
             void QPieSeries::setHoverHighlighting(bool enable)
             {
                 if (enable) {
                     connect(this, SIGNAL(hoverEnter(QPieSlice*)), this, SLOT(highlightOn(QPieSlice*)));
                     connect(this, SIGNAL(hoverLeave(QPieSlice*)), this, SLOT(highlightOff(QPieSlice*)));
                 } else {
                     disconnect(this, SLOT(hoverEnter(QPieSlice*)));
                     disconnect(this, SLOT(hoverLeave(QPieSlice*)));
                 }
             }
             /*!
+                Returns the sum of all slice values in this series.
+                \sa QPieSlice::value(), QPieSlice::setValue()
+            */
+            qreal QPieSeries::total() const
+            {
+                return m_total;
+            }
+            /*!
                 \fn void QPieSeries::changed(const QPieSeries::ChangeSet& changeSet)
                 This signal emitted when something has changed in the series.
                 The \a changeSet contains the details of which slices have been added, changed or removed.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             /*!
                 \fn void QPieSeries::sizeFactorChanged()
                 This signal is emitted when size factor has been changed.
                 \sa sizeFactor(), setSizeFactor()
             */
             /*!
                 \fn void QPieSeries::positionChanged()
                 This signal is emitted when position of the pie has been changed.
                 \sa position(), setPosition()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 ChangeSet changeSet;
                 changeSet.appendChanged(slice);
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::toggleExploded(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 slice->setExploded(!slice->isExploded());
             }
             void QPieSeries::highlightOn(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().lighter();
                 slice->setBrush(c);
-                slice->setLabelVisible(true);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
-                slice->setLabelVisible(false);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
-                Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
+                if (m_total == 0) {
+                    qDebug() << "QPieSeries::updateDerivativeData() total == 0";
+                    Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
+                }
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = m_pieAngleSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         changed = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 0

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #include <QBrush>
             #include <QSignalMapper>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
                 class ChangeSet
                 {
                 public:
                     // TODO: these should not really be exposed to the public API
                     void appendAdded(QPieSlice* slice);
                     void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                     QList<QPieSlice*> added() const;
                     QList<QPieSlice*> changed() const;
                     QList<QPieSlice*> removed() const;
                     bool isEmpty() const;
                 private:
                     QList<QPieSlice*> m_added;
                     QList<QPieSlice*> m_changed;
                     QList<QPieSlice*> m_removed;
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 void replace(QList<QPieSlice*> slices);
                 void add(QList<QPieSlice*> slices);
                 void add(QPieSlice* slice);
                 QPieSlice* add(qreal value, QString name);
+                QPieSeries& operator << (QPieSlice* slice);
                 void remove(QPieSlice* slice);
                 void clear();
                 int count() const;
                 QList<QPieSlice*> slices() const;
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const;
                 void setPosition(PiePosition position);
                 PiePosition position() const;
                 void setSpan(qreal startAngle, qreal angleSpan);
                 void setLabelsVisible(bool visible = true);
                 void setClickExplodes(bool enable = true);
                 void setHoverHighlighting(bool enable = true);
+                qreal total() const;
                 // TODO: find slices?
                 // QList<QPieSlice*> findByValue(qreal value);
                 // ...
                 // TODO: sorting slices?
                 // void sort(QPieSeries::SortByValue|label|??)
                 // TODO: general graphics customization
                 // setDrawStyle(2d|3d)
                 // setDropShadows(bool)
             Q_SIGNALS:
                 void changed(const QPieSeries::ChangeSet& changeSet);
                 void clicked(QPieSlice* slice);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void sizeFactorChanged();
                 void positionChanged();
             private Q_SLOTS: // TODO: should be private and not visible in the interface at all
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void toggleExploded(QPieSlice* slice);
                 void highlightOn(QPieSlice* slice);
                 void highlightOff(QPieSlice* slice);
             private:
                 void updateDerivativeData();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class PiePresenter;
                 friend class PieSlice;
                 QList<QPieSlice*> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
                 qreal m_total;
                 qreal m_pieStartAngle;
                 qreal m_pieAngleSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/qseries.cpp +14 0

             #include "qseries.h"
             /*!
                 \class QSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QScatterSeries
             */
             /*!
                 \enum QSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \fn QSeries::QSeries(QObject *parent)
                 \brief Constructs ChartSeries object with \a parent.
             */
             /*!
                 \fn QSeries::~QSeries()
                 \brief Virtual destructor for the chart series.
             */
             /*!
                 \fn QSeriesType QSeries::type() const
                 \brief The type of the series.
             */
             /*!
                 \fn bool QSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
                 \fn QList<QSeries::Legend> QSeries::legend()
                 \brief Returns the legend of the series. If series is empty, empty list is returned.
             */
+            /*!
+                \fn void QSeries::setTitle(QString title)
+                \brief Sets a \a title for the series.
+                This is not used directly by the chart itself. It is up to the user to use this as for example
+                chart title.
+                \sa QChart::setChartTitle()
+            */
+            /*!
+                \fn QString QSeries::title()
+                \brief Returns the title of the series.
+            */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #include "moc_qseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qseries.h +6 0

             #ifndef QSERIES_H
             #define QSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QAbstractItemModel>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
             {
                 Q_OBJECT
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
                 // Helper class to contain legend and color for it
                 // TODO: This as private class? Or should we expose this to user of API
                 class Legend {
                 public:
                     QString mName;
                     QPen mPen;
                 };
             protected:
                 QSeries(QObject *parent = 0) : QObject(parent) {}
             public:
                 virtual ~QSeries() {}
                 virtual QSeriesType type() const = 0;
                 // TODO
                 virtual bool setModel(QAbstractItemModel* /*model*/) { return false; }
                 // TODO: should this be internal?
                 virtual QList<QSeries::Legend> legend() { QList<QSeries::Legend> l; return l; }
+                void setTitle(QString title) { m_title = title; }
+                QString title() { return m_title; }
+            private:
+                QString m_title;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/auto/chartdataset/tst_chartdataset.cpp +67 -51

             #include <QtTest/QtTest>
             #include <qchartaxis.h>
             #include <qlineseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain)
             Q_DECLARE_METATYPE(QChartAxis*)
             Q_DECLARE_METATYPE(QSeries*)
             Q_DECLARE_METATYPE(QLineSeries*)
             class tst_ChartDataSet: public QObject {
             Q_OBJECT
             public slots:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private slots:
             	void chartdataset_data();
             	void chartdataset();
             	void addDomain_data();
             	void addDomain();
             	void addSeries_data();
             	void addSeries();
             	void axisY_data();
             	void axisY();
             	void clearDomains_data();
             	void clearDomains();
             	void domain_data();
             	void domain();
             	void nextpreviousDomain_data();
             	void nextpreviousDomain();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
             };
             void tst_ChartDataSet::initTestCase()
             {
             	qRegisterMetaType<Domain>("Domain");
             	qRegisterMetaType<QChartAxis*>();
             	qRegisterMetaType<QSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
             }
             void tst_ChartDataSet::cleanup()
             {
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	ChartDataSet dataSet;
             	QVERIFY2(dataSet.axisX(), "Missing axisX.");
             	QVERIFY2(dataSet.axisY(), "Missing axisY.");
             	//check if not dangling pointer
             	dataSet.axisX()->objectName();
             	dataSet.axisY()->objectName();
             	QVERIFY(dataSet.domain(dataSet.axisX())==Domain());
             	QVERIFY(dataSet.domain(dataSet.axisY())==Domain());
             	QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::addDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::addDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineSeries series;
             	series.add(0, 0);
             	series.add(1000, 1000);
             	dataSet.addSeries(&series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 2);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 1);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::addSeries_data()
             {
-            	QTest::addColumn<int>("seriesCount");
+            	QTest::addColumn<int>("defaultAxisCount");
-            	QTest::addColumn<int>("axisYCount");
+                QTest::addColumn<int>("firstAxisCount");
-            	QTest::newRow("2 series, default axis") << 2 << 0;
+                QTest::addColumn<int>("secoundAxisCount");
-            	QTest::newRow("2 series, 2 new axis") << 2 << 2;
+            	QTest::newRow("2 ,1 ,0") << 2 << 1 << 0;
-            	QTest::newRow("2 series, 1 new axis") << 2 << 2;
+            	QTest::newRow("2 series, 2 new axis") << 2 << 0 << 2;
-            	QTest::newRow("3 series, 3 new axis") << 3 << 3;
+            	QTest::newRow("2 series, 1 new axis") << 2 << 0 << 2;
-            	QTest::newRow("3 series, 2 new axis") << 3 << 2;
+            	QTest::newRow("3 series, 3 new axis") << 3 << 0 << 3;
-            	QTest::newRow("3 series, 1 new axis") << 3 << 1;
+            	QTest::newRow("3 series, 2 new axis") << 3 << 0 << 2;
+            	QTest::newRow("3 series, 1 new axis") << 3 << 0 << 1;
+                QTest::newRow("3 series, default + 1 new axis") << 3 << 0 << 1;
             }
             void tst_ChartDataSet::addSeries()
             {
-            	QFETCH(int, seriesCount);
+                QFETCH(int, defaultAxisCount);
-            	QFETCH(int, axisYCount);
+                QFETCH(int, firstAxisCount);
+                QFETCH(int, secoundAxisCount);
-            	ChartDataSet dataSet;
+                ChartDataSet dataSet;
-            	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
-            	QSignalSpy spy1(&dataSet,
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
-            			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
+                QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
+                QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy4(&dataSet,
+                QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
-            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
-            	QList<QChartAxis*> axisList;
+                for (int i = 0; i < defaultAxisCount; i++) {
+                    QLineSeries* series = new QLineSeries();
+                    dataSet.addSeries(series);
+                }
-            	for (int i = 0; i < axisYCount; i++) {
+                QChartAxis* firstAxis = new QChartAxis();
-            		QChartAxis* axis = new QChartAxis();
-            		axisList << axis;
-            	QList<QChartAxis*>::iterator iterator = axisList.begin();
+                for (int i = 0; i < firstAxisCount; i++) {
+                    QLineSeries* series = new QLineSeries();
+                    dataSet.addSeries(series, firstAxis);
+                }
-            	for (int i = 0; i < seriesCount; i++) {
+                QChartAxis* secoundAxis = new QChartAxis();
-            		QChartAxis* axisY = 0;
-            		QLineSeries* series = new QLineSeries();
+                for (int i = 0; i < secoundAxisCount; i++) {
-            		if (iterator != axisList.end()) {
+                    QLineSeries* series = new QLineSeries();
-            			axisY = *iterator;
+                    dataSet.addSeries(series, secoundAxis);
-            			iterator++;
-            		} else if (axisList.count() > 0) {
-            			iterator--;
-            			axisY = *iterator;
-            			iterator++;
-            		dataSet.addSeries(series, axisY);
-            	//default axis
+                int axisCount = 1;
-            	if (axisYCount == 0)
-            		axisYCount+=2;
-            	else
-            	    axisYCount++;
-            	QCOMPARE(spy0.count(), axisYCount);
+                if (defaultAxisCount > 0)
-            	QCOMPARE(spy1.count(), seriesCount*2);
+                    axisCount++;
-            	QCOMPARE(spy2.count(), 0);
+                if (firstAxisCount > 0)
-            	QCOMPARE(spy3.count(), seriesCount);
+                    axisCount++;
-            	QCOMPARE(spy4.count(), seriesCount);
+                if (secoundAxisCount > 0)
-            	QCOMPARE(spy5.count(), 0);
+                    axisCount++;
-            	QCOMPARE(dataSet.domainIndex(), 0);
+                QCOMPARE(spy0.count(), axisCount);
+                QCOMPARE(spy1.count(), (defaultAxisCount + firstAxisCount + secoundAxisCount)*2);
+                QCOMPARE(spy2.count(), 0);
+                QCOMPARE(spy3.count(), defaultAxisCount + firstAxisCount + secoundAxisCount);
+                int i = 0;
+                while (defaultAxisCount) {
+                    i+=defaultAxisCount;
+                    defaultAxisCount--;
+                }
+                int j = 0;
+                while (firstAxisCount>0) {
+                    j += firstAxisCount;
+                    firstAxisCount--;
+                }
+                int k = 0;
+                while (secoundAxisCount>0) {
+                    k += secoundAxisCount;
+                    secoundAxisCount--;
+                }
+                QCOMPARE(spy4.count(),i + j + k);
+                QCOMPARE(spy5.count(), 0);
+                QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::axisY_data()
             {
             	QTest::addColumn<QChartAxis*>("axisY");
             	QTest::newRow("axisY1") << new QChartAxis();
             	QTest::newRow("axisY2") << new QChartAxis();
             }
             void tst_ChartDataSet::axisY()
             {
             	QFETCH(QChartAxis*, axisY);
             	ChartDataSet dataSet;
             	QChartAxis* defaultAxisY = dataSet.axisY();
             	QVERIFY2(defaultAxisY, "Missing axisY.");
             	QLineSeries* series1 = new QLineSeries();
             	dataSet.addSeries(series1);
             	QLineSeries* series2 = new QLineSeries();
             	dataSet.addSeries(series2, axisY);
             	QVERIFY(dataSet.axisY(series1) == defaultAxisY);
             	QVERIFY(dataSet.axisY(series2) == axisY);
             }
             void tst_ChartDataSet::clearDomains_data()
             {
             	QTest::addColumn<int>("indexCount");
             	QTest::newRow("0") << 0;
             	QTest::newRow("1") << 1;
             	QTest::newRow("5") << 2;
             	QTest::newRow("8") << 3;
             }
             void tst_ChartDataSet::clearDomains()
             {
             	QFETCH(int, indexCount);
             	Domain domain1(0, 100, 0, 100);
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 0);
             	series->add(100, 100);
             	ChartDataSet dataSet;
             	QCOMPARE(dataSet.domainIndex(), 0);
             	dataSet.addSeries(series);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domain1);
             	QList<Domain> domains;
             	domains << domain1;
             	for (int i = 0; i < indexCount; i++) {
             		dataSet.addDomain(QRect(0, 0, 10, 10), QRect(0, 0, 100, 100));
             		domains << dataSet.domain(dataSet.axisY());
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	dataSet.clearDomains(indexCount);
             	QCOMPARE(dataSet.domainIndex(), indexCount);
             	domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domains.at(indexCount));
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::domain_data()
             {
             	QTest::addColumn<Domain>("domain1");
             	QTest::addColumn<Domain>("domain2");
             	QTest::addColumn<Domain>("domain3");
             	QTest::addColumn<Domain>("domain");
             	QTest::newRow("Domain(0,10,0,10)") << Domain(0, 10, 0, 10)
             			<< Domain(0, 5, 0, 5) << Domain(0, 3, 0, 3) << Domain(0, 10, 0, 10);
             	QTest::newRow("Domain(-1,11,0,11)") << Domain(-1, 10, 0, 10)
             			<< Domain(0, 11, 0, 11) << Domain(0, 3, 0, 3)
             			<< Domain(-1, 11, 0, 11);
             	QTest::newRow("Domain(-5,5,1,8)") << Domain(-5, 0, 1, 1)
             			<< Domain(0, 5, 0, 8) << Domain(1, 2, 1, 2) << Domain(-5, 5, 0, 8);
             }
             void tst_ChartDataSet::domain()
             {
             	QFETCH(Domain, domain1);
             	QFETCH(Domain, domain2);
             	QFETCH(Domain, domain3);
             	QFETCH(Domain, domain);
             	ChartDataSet dataSet;
             	QLineSeries* series1 = new QLineSeries();
             	series1->add(domain1.m_minX, domain1.m_minY);
             	series1->add(domain1.m_maxX, domain1.m_maxY);
             	QLineSeries* series2 = new QLineSeries();
             	series2->add(domain2.m_minX, domain2.m_minY);
             	series2->add(domain2.m_maxX, domain2.m_maxY);
             	QLineSeries* series3 = new QLineSeries();
             	series3->add(domain3.m_minX, domain3.m_minY);
             	series3->add(domain3.m_maxX, domain3.m_maxY);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	dataSet.addSeries(series1);
             	dataSet.addSeries(series2);
             	dataSet.addSeries(series3);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QVERIFY2(dataSet.domain(dataSet.axisY()) == domain, "Domain not equal");
             	QCOMPARE(spy0.count(), 2);
             	QCOMPARE(spy1.count(), 6);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 3);
-            	QCOMPARE(spy4.count(), 3);
+            	QCOMPARE(spy4.count(), 6);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::nextpreviousDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::nextpreviousDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 0);
             	series->add(1000, 1000);
             	dataSet.addSeries(series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	Domain domain5 = dataSet.domain(dataSet.axisY());
             	Domain domain6 = domain3.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain5 == domain6);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 3);
             	Domain domain7 = dataSet.domain(dataSet.axisY());
             	Domain domain8 = domain5.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain7 == domain8);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	Domain domain;
             	bool previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain5);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain3);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, false);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	bool next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),1);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),2);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),3);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, false);
             	QCOMPARE(dataSet.domainIndex(),3);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 12);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 6);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
             	QTest::addColumn<int>("seriesCount");
             	QTest::addColumn<int>("axisYCount");
             	QTest::newRow("2 series, default axis") << 2 << 0;
             	QTest::newRow("2 series, 2 new axis") << 2 << 2;
             	QTest::newRow("2 series, 1 new axis") << 2 << 2;
             	QTest::newRow("3 series, 3 new axis") << 3 << 3;
             	QTest::newRow("3 series, 2 new axis") << 3 << 2;
             	QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::removeSeries()
             {
             	QFETCH(int, seriesCount);
             	QFETCH(int, axisYCount);
             	ChartDataSet dataSet;
             	QList<QChartAxis*> axisList;
             	QList<QSeries*> seriesList;
             	for (int i = 0; i < axisYCount; i++) {
             		QChartAxis* axis = new QChartAxis();
             		axisList << axis;
             	}
             	QList<QChartAxis*>::iterator iterator = axisList.begin();
             	for (int i = 0; i < seriesCount; i++) {
             		QChartAxis* axisY = 0;
             		QLineSeries* series = new QLineSeries();
             		if (iterator != axisList.end()) {
             			axisY = *iterator;
             			iterator++;
             		} else if (axisList.count() > 0) {
             			iterator--;
             			axisY = *iterator;
             			iterator++;
             		}
             		dataSet.addSeries(series, axisY);
             		seriesList << series;
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	for (int i = 0; i < seriesCount; i++) {
             		dataSet.removeSeries(seriesList.at(i));
             	}
                 //default axis
                 if (axisYCount == 0)
                     axisYCount++;
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), axisYCount);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), seriesCount);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	qDeleteAll(seriesList);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<int>("seriesCount");
                 QTest::addColumn<int>("axisYCount");
                 QTest::newRow("2 series, default axis") << 2 << 0;
                 QTest::newRow("2 series, 2 new axis") << 2 << 2;
                 QTest::newRow("2 series, 1 new axis") << 2 << 2;
                 QTest::newRow("3 series, 3 new axis") << 3 << 3;
                 QTest::newRow("3 series, 2 new axis") << 3 << 2;
                 QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(int, seriesCount);
                 QFETCH(int, axisYCount);
                 ChartDataSet dataSet;
                 QList<QChartAxis*> axisList;
                 for (int i = 0; i < axisYCount; i++) {
                     QChartAxis* axis = new QChartAxis();
                     axisList << axis;
                 }
                 QList<QChartAxis*>::iterator iterator = axisList.begin();
                 for (int i = 0; i < seriesCount; i++) {
                     QChartAxis* axisY = 0;
                     QLineSeries* series = new QLineSeries();
                     if (iterator != axisList.end()) {
                         axisY = *iterator;
                         iterator++;
                     } else if (axisList.count() > 0) {
                         iterator--;
                         axisY = *iterator;
                         iterator++;
                     }
                     dataSet.addSeries(series, axisY);
                 }
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
                 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
                 QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
                 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 dataSet.removeAllSeries();
                 //default axis
                 if (axisYCount == 0)
                     axisYCount++;
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), axisYCount);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), seriesCount);
                 QCOMPARE(dataSet.domainIndex(), 0);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.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