HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r173:5bd6f6e4373b

fixed bug in category implementation. model now owns the category and sets

sauimone -

r173:5bd6f6e4373b

parent child

Context file:

r173:5bd6f6e4373b

Expand all files

example/barchart/main.cpp +18 -18

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <barchartseries.h>
             #include <qbarcategory.h>
             #include <qbarset.h>
             #include "chartwidget.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QBarCategory category;
+                QBarCategory *category = new QBarCategory;
-                category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 BarChartSeries* series0 = new BarChartSeries(category);
-                QBarSet barSet0;
+                QBarSet *set0 = new QBarSet;
-                QBarSet barSet1;
+                QBarSet *set1 = new QBarSet;
-                QBarSet barSet2;
+                QBarSet *set2 = new QBarSet;
-                QBarSet barSet3;
+                QBarSet *set3 = new QBarSet;
-                QBarSet barSet4;
+                QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
-                barSet0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
+                *set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
-                barSet1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
+                *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
-                barSet2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
+                *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
-                barSet3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
+                *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
-                barSet4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
+                *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
-                series0->addBarSet(barSet0);
+                series0->addBarSet(set0);
-                series0->addBarSet(barSet1);
+                series0->addBarSet(set1);
-                series0->addBarSet(barSet2);
+                series0->addBarSet(set2);
-                series0->addBarSet(barSet3);
+                series0->addBarSet(set3);
-                series0->addBarSet(barSet4);
+                series0->addBarSet(set4);
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->addSeries(series0);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/percentbarchart/main.cpp +18 -18

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <percentbarchartseries.h>
             #include "chartwidget.h"
             #include <qbarcategory.h>
             #include <qbarset.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QBarCategory category;
+                QBarCategory *category = new QBarCategory;
-                category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 PercentBarChartSeries* series0 = new PercentBarChartSeries(category);
-                QBarSet barSet0;
+                QBarSet *set0 = new QBarSet;
-                QBarSet barSet1;
+                QBarSet *set1 = new QBarSet;
-                QBarSet barSet2;
+                QBarSet *set2 = new QBarSet;
-                QBarSet barSet3;
+                QBarSet *set3 = new QBarSet;
-                QBarSet barSet4;
+                QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
-                barSet0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
+                *set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
-                barSet1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
+                *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
-                barSet2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
+                *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
-                barSet3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
+                *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
-                barSet4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
+                *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
-                series0->addBarSet(barSet0);
+                series0->addBarSet(set0);
-                series0->addBarSet(barSet1);
+                series0->addBarSet(set1);
-                series0->addBarSet(barSet2);
+                series0->addBarSet(set2);
-                series0->addBarSet(barSet3);
+                series0->addBarSet(set3);
-                series0->addBarSet(barSet4);
+                series0->addBarSet(set4);
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->addSeries(series0);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/stackedbarchart/main.cpp +18 -18

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <stackedbarchartseries.h>
             #include "chartwidget.h"
             #include <qbarset.h>
             #include <qbarcategory.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QBarCategory category;
+                QBarCategory *category = new QBarCategory;
-                category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 StackedBarChartSeries* series0 = new StackedBarChartSeries(category);
-                QBarSet barSet0;
+                QBarSet *set0 = new QBarSet;
-                QBarSet barSet1;
+                QBarSet *set1 = new QBarSet;
-                QBarSet barSet2;
+                QBarSet *set2 = new QBarSet;
-                QBarSet barSet3;
+                QBarSet *set3 = new QBarSet;
-                QBarSet barSet4;
+                QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
-                barSet0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
+                *set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
-                barSet1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
+                *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
-                barSet2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
+                *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
-                barSet3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
+                *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
-                barSet4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
+                *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
-                series0->addBarSet(barSet0);
+                series0->addBarSet(set0);
-                series0->addBarSet(barSet1);
+                series0->addBarSet(set1);
-                series0->addBarSet(barSet2);
+                series0->addBarSet(set2);
-                series0->addBarSet(barSet3);
+                series0->addBarSet(set3);
-                series0->addBarSet(barSet4);
+                series0->addBarSet(set4);
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->addSeries(series0);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/barchart/barchartmodel.cpp +16 -8

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartModel::BarChartModel(QBarCategory &category, QObject *parent) :
+            BarChartModel::BarChartModel(QBarCategory *category, QObject *parent) :
                 QObject(parent)
                 ,mCategory(category)
             {
             }
-            QBarCategory& BarChartModel::category()
+            BarChartModel::~BarChartModel()
             {
-                return mCategory;
+                delete mCategory;
             }
-            void BarChartModel::addBarSet(QBarSet &set)
+            QBarCategory& BarChartModel::category()
             {
-                mDataModel.append(&set);
+                return *mCategory;
             }
-            void BarChartModel::removeBarSet(QBarSet &set)
+            void BarChartModel::addBarSet(QBarSet *set)
             {
-                mDataModel.removeOne(&set);
+                mDataModel.append(set);
             }
+            void BarChartModel::removeBarSet(QBarSet *set)
+            {
+                if (mDataModel.contains(set)) {
+                    mDataModel.removeOne(set);
+                    delete set;
+                }
+            }
             int BarChartModel::countSets()
             {
                 return mDataModel.count();
             }
             int BarChartModel::countCategories()
             {
                 int count(0);
                 for (int i=0; i<mDataModel.count(); i++){
                     // TODO: can we assume that all series have same number of values? If not. then which values are empty?
                     int temp = mDataModel.at(i)->count();
                     if (temp > count) {
                         count = temp;
                     }
                 }
                 return count;
             }
             int BarChartModel::countTotalItems()
             {
                 int total = mDataModel.count() * countCategories();
                 return total;
             }
             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::categorySum(int column)
             {
                 qreal sum(0);
                 int count = mDataModel.count(); // Count rows
                 for (int row = 0; row < count; row++) {
                     if (column < mDataModel.at(row)->count()) {
                         sum += mDataModel.at(row)->valueAt(column);
                     }
                 }
                 return sum;
             }
             qreal BarChartModel::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = countCategories();
                 for (int col=0; col<count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max) {
                         max = sum;
                     }
                 }
                 return max;
             }
             QString BarChartModel::label(int category)
             {
-                return mCategory.label(category);
+                return mCategory->label(category);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +5 -4

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class QBarCategory;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
-                explicit BarChartModel(QBarCategory &category, QObject *parent = 0);
+                explicit BarChartModel(QBarCategory *category, QObject *parent = 0);
+                ~BarChartModel();
                 QBarCategory& category();
-                void addBarSet(QBarSet &set);
+                void addBarSet(QBarSet *set);
-                void removeBarSet(QBarSet &set);
+                void removeBarSet(QBarSet *set);
                 int countSets();            // Number of sets in model
                 int countCategories();      // Number of categories
                 int countTotalItems();      // Total items in all sets. Includes empty items.
                 qreal max();                // Maximum value of all sets
                 qreal min();                // Minimum value of all sets
                 qreal valueAt(int set, int category);
                 qreal categorySum(int column);
                 qreal maxCategorySum();     // returns maximum sum of sets in all categories.
                 QString label(int category);
             signals:
                 void modelUpdated();
             public slots:
             private:
                 QList<QBarSet*> mDataModel;
-                QBarCategory& mCategory;
+                QBarCategory* mCategory;    // Owned
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barchartseries.cpp +3 -3

             #include <QDebug>
             #include "barchartseries.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartSeries::BarChartSeries(QBarCategory &category, QObject *parent)
+            BarChartSeries::BarChartSeries(QBarCategory *category, QObject *parent)
                 : QChartSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
-            void BarChartSeries::addBarSet(QBarSet &set)
+            void BarChartSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
             }
-            void BarChartSeries::removeBarSet(QBarSet &set)
+            void BarChartSeries::removeBarSet(QBarSet *set)
             {
                 mModel->removeBarSet(set);
             }
             int BarChartSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             qreal BarChartSeries::min()
             {
                 return mModel->min();
             }
             qreal BarChartSeries::max()
             {
                 return mModel->max();
             }
             qreal BarChartSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             qreal BarChartSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             BarChartModel& BarChartSeries::model()
             {
                 return *mModel;
             }
             #include "moc_barchartseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartseries.h +8 -4

             #ifndef BARCHARTSERIES_H
             #define BARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QBarSet;
             class BarGroup;
             class BarChartModel;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT BarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                BarChartSeries(QBarCategory &category, QObject* parent=0);
+                BarChartSeries(QBarCategory *category, QObject* parent=0);
-                // from BarChartSeriesBase
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeBar; }
-                void addBarSet(QBarSet &set);
+                void addBarSet(QBarSet *set);       // Takes ownership
-                void removeBarSet(QBarSet &set);
+                void removeBarSet(QBarSet *set);    // Also deletes the set, if set is owned.
+                //TODO:
+                //QList<QString> legend();  // Returns legend of series (ie. names of all sets in series)
+                // TODO: Functions below this are not part of api and will be moved
+                // to private implementation, when we start using it (not part of api)
                 int countCategories();
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
             signals:
                 void changed(int index);
             public Q_SLOTS:
             private:
                 BarGroup* mBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTSERIES_H

src/barchart/bargroup.cpp +2 -1

             #include "bargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroup::BarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model,parent)
             {
-                mBarDefaultWidth = 10;
+                mBarDefaultWidth = 5;
             }
             void BarGroup::layoutChanged()
             {
             //    qDebug() << "BarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
+                    qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout?
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int itemCount = mModel.countCategories();
                 int seriesCount = mModel.countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mModel.max();
                 qreal scale = (tH/tM);
                 qreal tC = itemCount+1;
                 qreal xStepPerSeries = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
                 int labelIndex = itemCount * seriesCount;
                 for (int item=0; item < itemCount; item++) {
                     qreal xPos = xStepPerSeries * item + ((tW + mBarDefaultWidth*seriesCount)/(itemCount*2));
                     qreal yPos = mHeight;
                     for (int series = 0; series < seriesCount; series++) {
                         qreal barHeight = mModel.valueAt(series, item) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(series));
                         bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + series * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerSeries * item + ((tW + mBarDefaultWidth*seriesCount)/(itemCount*2));
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bargroupbase.cpp +4 -7

             #include "bargroupbase.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroupBase::BarGroupBase(BarChartModel& model, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mSeparatorsVisible(true)
                 ,mModel(model)
-            //    ,mSeries(series)
             {
                 dataChanged();
             }
             void BarGroupBase::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
             }
             void BarGroupBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             //    qDebug() << "BarGroupBase::paint" << childItems().count();
                 if (!mLayoutSet) {
                     qDebug() << "BarGroupBase::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 BarGroupBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarGroupBase::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             int BarGroupBase::addColor( QColor color )
             {
             //    qDebug() << "BarGroupBase::addColor";
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
             void BarGroupBase::resetColors()
             {
             //    qDebug() << "BarGroupBase::resetColors";
                 mColors.clear();
             }
             void BarGroupBase::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
-                int totalItems = mModel.countTotalItems();  // mSeries.countTotalItems();
+                int totalItems = mModel.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
-                int count = mModel.countCategories();    // mSeries.countColumns();
+                int count = mModel.countCategories();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     label->set(mModel.label(i));
                     childItems().append(label);
                 }
-                count = mModel.countCategories() - 1;    // mSeries.countColumns() - 1; // There is one less separator than columns
+                count = mModel.countCategories() - 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
                     childItems().append(sep);
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             //handlers
             void BarGroupBase::handleModelChanged(int index)
             {
-                qDebug() << "BarGroupBase::handleModelChanged" << index;
+            //    qDebug() << "BarGroupBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarGroupBase::handleDomainChanged(const Domain& domain)
             {
             //    qDebug() << "BarGroupBase::handleDomainChanged";
                 // TODO: Figure out the use case for this.
                 // Affects the size of visible item, so layout is changed.
             //    layoutChanged();
             }
             void BarGroupBase::handleGeometryChanged(const QRectF& rect)
             {
-            //    qDebug() << "BarGroupBase::handleGeometryChanged";
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             #include "moc_bargroupbase.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartseries.cpp +3 -3

             #include "percentbarchartseries.h"
             #include <limits.h>
             #include <QDebug>
             #include "percentbarchartseries.h"
             #include "qbarset.h"
             #include "qbarcategory.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarChartSeries::PercentBarChartSeries(QBarCategory &category, QObject *parent)
+            PercentBarChartSeries::PercentBarChartSeries(QBarCategory *category, QObject *parent)
                 : QChartSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
-            void PercentBarChartSeries::addBarSet(QBarSet &set)
+            void PercentBarChartSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
             }
-            void PercentBarChartSeries::removeBarSet(QBarSet &set)
+            void PercentBarChartSeries::removeBarSet(QBarSet *set)
             {
                 mModel->removeBarSet(set);
             }
             int PercentBarChartSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             qreal PercentBarChartSeries::min()
             {
                 return mModel->min();
             }
             qreal PercentBarChartSeries::max()
             {
                 return mModel->max();
             }
             qreal PercentBarChartSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             qreal PercentBarChartSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             BarChartModel& PercentBarChartSeries::model()
             {
                 return *mModel;
             }
             #include "moc_percentbarchartseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartseries.h +8 -3

             #ifndef PERCENTBARCHARTSERIES_H
             #define PERCENTBARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PercentBarGroup;
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
             class QTCOMMERCIALCHART_EXPORT PercentBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                PercentBarChartSeries(QBarCategory &category, QObject* parent=0);
+                PercentBarChartSeries(QBarCategory *category, QObject* parent=0);
                 // from BarChartSeriesBase
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypePercentBar; }
-                void addBarSet(QBarSet &set);
+                void addBarSet(QBarSet *set);       // Takes ownership
-                void removeBarSet(QBarSet &set);
+                void removeBarSet(QBarSet *set);    // Also deletes the set, if set is owned.
+                //TODO:
+                //QList<QString> legend();  // Returns legend of series (ie. names of all sets in series)
+                // TODO: Functions below this are not part of api and will be moved
+                // to private implementation, when we start using it (not part of api)
                 int countCategories();
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
             signals:
                 void changed(int index);
             public Q_SLOTS:
             private:
                 PercentBarGroup* mPercentBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARCHARTSERIES_H

src/barchart/percentbargroup.cpp +2 0

             #include "percentbargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarGroup::PercentBarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model, parent)
             {
             }
             void PercentBarGroup::layoutChanged()
             {
+            //    qDebug() << "PercentBarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
+                    qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: PercentBarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int count = mModel.countCategories();
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mModel.countCategories() * mModel.countSets();
                 for (int column = 0; column < mModel.countCategories(); column++) {
                     qreal colSum = mModel.categorySum(column);
                     qreal h = mHeight;
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int row=0; row < mModel.countSets(); row++) {
                         qreal barHeight = mModel.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 int separatorIndex = labelIndex;    // Separators are after labels in childItems(). TODO: better way to store these?
                 xPos = xStep + xStep/2;             // Initial position is between first and second group. ie one and half steps from left.
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = reinterpret_cast<Separator*> (childItems().at(separatorIndex));
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                     separatorIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarcategory.cpp +2 -1

             #include "qbarcategory.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarCategory::QBarCategory()
             {
             }
             QBarCategory& QBarCategory::operator << (const QString &label)
             {
                 mList.append(label);
                 return *this;
             }
             int QBarCategory::count()
             {
                 return mList.count();
             }
             QString QBarCategory::label(int category)
             {
                 return mList.at(category);
             }
+            // TODO?:
+            //#include "moc_qbarcategory.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarcategory.h +2 -1

             #ifndef QBARCATEGORY_H
             #define QBARCATEGORY_H
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QBarCategory // TODO? : pubclic QObject
+            class QTCOMMERCIALCHART_EXPORT QBarCategory // TODO?: : public QObject
             {
+            //    Q_OBJECT;
             public:
                 QBarCategory();
                 QBarCategory& operator << (const QString &label);
                 // Number of items in category
                 int count();
                 QString label(int category);
             public:
                 QList<QString> mList;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARCATEGORY_H

src/barchart/qbarset.cpp +2 -1

             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarSet::QBarSet()
             {
             }
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             QString QBarSet::name()
             {
                 return mName;
             }
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             int QBarSet::count()
             {
                 return mValues.count();
             }
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
+            //TODO?:
+            //#include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +2 -1

             #ifndef QBARSET_H
             #define QBARSET_H
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QBarSet // : pubclic QObject // TODO: Need for this?
+            class QTCOMMERCIALCHART_EXPORT QBarSet // TODO? : public QObject
             {
+                //Q_OBJECT;
             public:
                 QBarSet();
                 void setName(QString name);
                 QString name();
                 QBarSet& operator << (const qreal &value);
                 //TODO: What is the way to set a single value to n:th item? Is there need for such functionality?
                 int count();
                 qreal valueAt(int index);
             private:
                 QString mName;
                 QList<qreal> mValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarchartseries.cpp +3 -3

             #include <limits.h>
             #include <QDebug>
             #include "stackedbarchartseries.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarChartSeries::StackedBarChartSeries(QBarCategory &category, QObject *parent)
+            StackedBarChartSeries::StackedBarChartSeries(QBarCategory *category, QObject *parent)
                 : QChartSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
-            void StackedBarChartSeries::addBarSet(QBarSet &set)
+            void StackedBarChartSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
             }
-            void StackedBarChartSeries::removeBarSet(QBarSet &set)
+            void StackedBarChartSeries::removeBarSet(QBarSet *set)
             {
                 mModel->removeBarSet(set);
             }
             int StackedBarChartSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             qreal StackedBarChartSeries::min()
             {
                 return mModel->min();
             }
             qreal StackedBarChartSeries::max()
             {
                 return mModel->max();
             }
             qreal StackedBarChartSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             qreal StackedBarChartSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             BarChartModel& StackedBarChartSeries::model()
             {
                 return *mModel;
             }
             #include "moc_stackedbarchartseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarchartseries.h +8 -3

             #ifndef STACKEDBARCHARTSERIES_H
             #define STACKEDBARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class StackedBarGroup;
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
             class QTCOMMERCIALCHART_EXPORT StackedBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                StackedBarChartSeries(QBarCategory &category, QObject* parent=0);
+                StackedBarChartSeries(QBarCategory *category, QObject* parent=0);
                 // from QChartSeries
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeStackedBar; }
-                void addBarSet(QBarSet &set);
+                void addBarSet(QBarSet *set);       // Takes ownership
-                void removeBarSet(QBarSet &set);
+                void removeBarSet(QBarSet *set);    // Also deletes the set, if set is owned.
+                //TODO:
+                //QList<QString> legend();  // Returns legend of series (ie. names of all sets in series)
+                // TODO: Functions below this are not part of api and will be moved
+                // to private implementation, when we start using it (not part of api)
                 int countCategories();
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
             signals:
                 void changed(int index);
             public Q_SLOTS:
             private:
                 StackedBarGroup* mStackedBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARCHARTSERIES_H

src/barchart/stackedbargroup.cpp +2 -1

             #include "stackedbargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarGroup::StackedBarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model,parent)
             {
             }
             void StackedBarGroup::layoutChanged()
             {
             //    qDebug() << "StackedBarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
+                    qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mModel.countCategories() == 0) {
+                    qDebug() << "No categories in model!";
                     // Nothing to do
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: StackedBarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 // TODO: use temp variable for column count...
                 qreal maxSum = mModel.maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = mModel.countCategories() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mModel.countSets() * mModel.countCategories();
                 for (int column = 0; column < mModel.countCategories(); column++) {
                     qreal yPos = h;
                     for (int row=0; row < mModel.countSets(); row++) {
                         qreal barHeight = mModel.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 int separatorIndex = labelIndex;    // Separators are after labels in childItems(). TODO: better way to store these?
                 xPos = xStep + xStep/2;             // Initial position is between first and second group. ie one and half steps from left.
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = reinterpret_cast<Separator*> (childItems().at(separatorIndex));
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                     separatorIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +3 -1

             #include "chartdataset_p.h"
             //series
             #include "qlinechartseries.h"
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent)
             {
                 Domain domain;
                 m_domains<<domain;
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain& ChartDataSet::domain() const
             {
                 return m_domains[m_domainIndex];
             }
             void ChartDataSet::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 m_domainIndex = 0;
                 m_domains.resize(1);
                 Domain& domain = m_domains[m_domainIndex];
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* xyseries = static_cast<QLineChartSeries*>(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 QChartSeries::SeriesTypeBar: {
+                    qDebug() << "QChartSeries::SeriesTypeBar";
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         qreal x = barSeries->countCategories();
                         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 QChartSeries::SeriesTypeStackedBar: {
+                    qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         qreal x = stackedBarSeries->countCategories();
                         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 QChartSeries::SeriesTypePercentBar: {
+                    qDebug() << "QChartSeries::SeriesTypePercentBar";
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         qreal x = percentBarSeries->countCategories();
                         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 QChartSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QChartSeries::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;
                     }
                 }
                 emit seriesAdded(series);
                 emit domainChanged(domain);
             }
             bool ChartDataSet::nextDomain()
             {
                 if (m_domainIndex < m_domains.count() - 1) {
                     m_domainIndex++;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::clearDomains()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex = 0;
                     emit domainChanged(m_domains[m_domainIndex]);
                 }
             }
             void ChartDataSet::addDomain(const Domain& domain)
             {
                 m_domains.resize(m_domainIndex + 1);
                 m_domains << domain;
                 m_domainIndex++;
                 emit domainChanged(domain);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +1 0

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             #include "scatterpresenter.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_domainIndex(0),
             m_marginSize(0),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 setChartTheme(QChart::ChartThemeDefault);
                 m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
                 m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                 createConnections();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
                 QMapIterator<QChartAxis*,AxisItem*> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),i.value(),SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),i.value(),SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
+                qDebug() << " ChartPresenter::handleSeriesAdded";
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         BarGroup* item = new BarGroup(barSeries->model(),m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* item = new StackedBarGroup(stackedBarSeries->model(),m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* item = new PercentBarGroup(percentBarSeries->model(),m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)),
                                          scatterPresenter, SLOT(handleDomainChanged(const Domain&)));
             //            scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
             //            scatterSeries->d->setParentItem(this);
             //            scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::zoomInToRect(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 QRectF r = rect.normalized();
                 r.translate(-m_marginSize, -m_marginSize);
                 Domain domain (m_dataset->domain().subDomain(r,m_rect.width(),m_rect.height()));
                 m_dataset->addDomain(domain);
             }
             void ChartPresenter::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_rect;
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                     m_dataset->addDomain(domain);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void ChartPresenter::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                   }
                 }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             QChartAxis* ChartPresenter::axisX()
             {
                return m_axisX;
             }
             QChartAxis* ChartPresenter::axisY()
             {
                return m_axisY;
             }
             QChartAxis* ChartPresenter::addAxisX()
             {
               //only one axis
               if(m_axisX==0){
                   m_axisX = new QChartAxis(this);
                   m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
               }
               return m_axisX;
             }
             QChartAxis* ChartPresenter::addAxisY()
             {
                 if(m_axisY==0){
                     m_axisY = new QChartAxis(this);
                     m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                     return m_axisY;
                 }
                 QChartAxis* axis = new QChartAxis(this);
                 m_axisItems[axis] = new AxisItem(axis,AxisItem::Y_AXIS,m_chart);
                 return axis;
             }
             void ChartPresenter::removeAxis(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 if(item){
                     delete item;
                     delete axis;
                 }
                 //reset pointers to default ones
                 if(axis == m_axisX) m_axisX=0;
                 else if(axis == m_axisY) m_axisY=0;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

test/chartwidgettest/mainwidget.cpp +16 -16

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include <qlinechartseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             #include <barchartseries.h>
             #include <stackedbarchartseries.h>
             #include <percentbarchartseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 m_chartWidget = new QChartView(this);
                 m_chartWidget->setRubberBandPolicy(QChartView::HorizonalRubberBand);
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
                 connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartWidget, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 // Init series type specific controls
                 initPieControls();
                 mainLayout->addLayout(m_pieLayout, 2, 0);
                 // Scatter series specific settings
             //    m_scatterLayout = new QGridLayout();
             //    m_scatterLayout->addWidget(new QLabel("scatter"), 0, 0);
             //    m_scatterLayout->setEnabled(false);
             //    mainLayout->addLayout(m_scatterLayout, 1, 0);
                 // Add layouts and the chart widget to the main layout
                 mainLayout->addWidget(m_chartWidget, 0, 1, 3, 1);
                 setLayout(mainLayout);
                 // force an update to test data
                 testDataChanged(0);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Vanilla");
                 chartTheme->addItem("Icy");
                 chartTheme->addItem("Grayscale");
                 chartTheme->addItem("Scientific");
                 chartTheme->addItem("Unnamed1");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             void MainWidget::initPieControls()
             {
                 // Pie series specific settings
                 // Pie size factory
                 QDoubleSpinBox *pieSizeSpin = new QDoubleSpinBox();
                 pieSizeSpin->setMinimum(LONG_MIN);
                 pieSizeSpin->setMaximum(LONG_MAX);
                 pieSizeSpin->setValue(1.0);
                 pieSizeSpin->setSingleStep(0.1);
                 connect(pieSizeSpin, SIGNAL(valueChanged(double)), this, SLOT(setPieSizeFactor(double)));
                 // Pie position
                 QComboBox *piePosCombo = new QComboBox(this);
                 piePosCombo->addItem("Maximized");
                 piePosCombo->addItem("Top left");
                 piePosCombo->addItem("Top right");
                 piePosCombo->addItem("Bottom left");
                 piePosCombo->addItem("Bottom right");
                 connect(piePosCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(setPiePosition(int)));
                 m_pieLayout = new QGridLayout();
                 m_pieLayout->setEnabled(false);
                 m_pieLayout->addWidget(new QLabel("Pie size factor"), 0, 0);
                 m_pieLayout->addWidget(pieSizeSpin, 0, 1);
                 m_pieLayout->addWidget(new QLabel("Pie position"), 1, 0);
                 m_pieLayout->addWidget(piePosCombo, 1, 1);
             }
             void MainWidget::addSeries()
             {
                 DataSerieDialog dialog(m_defaultSeriesName, this);
                 connect(&dialog, SIGNAL(accepted(QString, QString)), this, SLOT(addSeries(QString, QString)));
                 dialog.exec();
             }
             void MainWidget::addSeries(QString series, QString data)
             {
                 qDebug() << "addSeries: " << series << " data: " << data;
                 m_defaultSeriesName = series;
                 // TODO: a dedicated data class for storing x and y values
                 QList<qreal> x;
                 QList<qreal> y;
-                QBarSet set0;
+                QBarSet *set0 = new QBarSet;
-                QBarSet set1;
+                QBarSet *set1 = new QBarSet;
-                QBarSet set2;
+                QBarSet *set2 = new QBarSet;
-                QBarSet set3;
+                QBarSet *set3 = new QBarSet;
-                QBarSet set4;
+                QBarSet *set4 = new QBarSet;
                 if (data == "linear") {
                     for (int i = 0; i < 20; i++) {
                         x.append(i);
                         y.append(i);
                     }
                 } else if (data == "linear, 1M") {
                     // 1 million data points from 0.0001 to 100
                     // TODO: What is the requirement? Should we be able to show this kind of data with
                     // reasonable performance, or can we expect the application developer to do "data mining"
                     // for us, so that the count of data points given to QtCommercial Chart is always
                     // reasonable?
                     for (qreal i = 0; i < 100; i += 0.0001) {
                         x.append(i);
                         y.append(20);
                     }
                 } else if (data == "SIN") {
                     for (int i = 0; i < 100; i++) {
                         x.append(i);
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                     }
                 } else if (data == "SIN + random") {
                     for (qreal i = 0; i < 100; i += 0.1) {
                         x.append(i + (rand() % 5));
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                     }
                 } else if (data == "Table, 5 series"){
                      // Create some test data to chart
-                    set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
+                    *set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
-                    set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
+                    *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
-                    set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
+                    *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
-                    set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
+                    *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
-                    set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
+                    *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
                 } else {
                     // TODO: check if data has a valid file name
                     Q_ASSERT(false);
                 }
                 // TODO: color of the series
                 QChartSeries *newSeries = 0;
                 if (series == "Scatter") {
                     newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypeScatter);
                     Q_ASSERT(newSeries->setData(x, y));
                 } else if (series == "Pie") {
                     newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypePie);
                     Q_ASSERT(newSeries->setData(y));
                 } else if (series == "Line") {
                     // TODO: adding data to an existing line series does not give any visuals for some reason
             //        newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypeLine);
             //        QXYChartSeries *lineSeries = static_cast<QXYChartSeries *>(newSeries);
             //        lineSeries->setColor(Qt::blue);
             //        for (int i(0); i < x.count() && i < y.count(); i++) {
             //            lineSeries->add(x.at(i), y.at(i));
             //        }
                     //Q_ASSERT(newSeries->setData(x, y));
                     QLineChartSeries* series0 = new QLineChartSeries();
                     for (int i(0); i < x.count() && i < y.count(); i++)
                         series0->add(x.at(i), y.at(i));
                     m_chartWidget->addSeries(series0);
                     newSeries = series0;
                 } else if (series == "Bar") {
                     qDebug() << "Bar chart series";
-                    QBarCategory category;
+                    QBarCategory *category = new QBarCategory;
-                    category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                    *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                     BarChartSeries* series0 = new BarChartSeries(category, this);
                     series0->addBarSet(set0);
                     series0->addBarSet(set1);
                     series0->addBarSet(set2);
                     series0->addBarSet(set3);
                     series0->addBarSet(set4);
                     m_chartWidget->addSeries(series0);
                     newSeries = series0;
                 } else if (series == "StackedBar") {
                     qDebug() << "Stacked bar chart series";
-                    QBarCategory category;
+                    QBarCategory *category = new QBarCategory;
-                    category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                    *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                     StackedBarChartSeries* series0 = new StackedBarChartSeries(category, this);
                     series0->addBarSet(set0);
                     series0->addBarSet(set1);
                     series0->addBarSet(set2);
                     series0->addBarSet(set3);
                     series0->addBarSet(set4);
                     m_chartWidget->addSeries(series0);
                     newSeries = series0;
                 } else if (series == "PercentBar") {
                     qDebug() << "Percent bar chart series";
-                    QBarCategory category;
+                    QBarCategory *category = new QBarCategory;
-                    category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
+                    *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                     PercentBarChartSeries* series0 = new PercentBarChartSeries(category, this);
                     series0->addBarSet(set0);
                     series0->addBarSet(set1);
                     series0->addBarSet(set2);
                     series0->addBarSet(set3);
                     series0->addBarSet(set4);
                     m_chartWidget->addSeries(series0);
                     newSeries = series0;
                 } else {
                     qDebug() << "Something weird going on in MainWidget::addSeries";
                 }
                 setCurrentSeries(newSeries);
             }
             void MainWidget::setCurrentSeries(QChartSeries *series)
             {
                 m_currentSeries = series;
                 switch (m_currentSeries->type()) {
                 case QChartSeries::SeriesTypeLine:
                     break;
                 case QChartSeries::SeriesTypeScatter:
                     break;
                 case QChartSeries::SeriesTypePie:
                     break;
                 case QChartSeries::SeriesTypeBar:
                     qDebug() << "setCurrentSeries (bar)";
                     break;
                 case QChartSeries::SeriesTypeStackedBar:
                     qDebug() << "setCurrentSeries (Stackedbar)";
                     break;
                 case QChartSeries::SeriesTypePercentBar:
                     qDebug() << "setCurrentSeries (Percentbar)";
                     break;
                 default:
                     Q_ASSERT(false);
                     break;
                 }
             }
             void MainWidget::testDataChanged(int itemIndex)
             {
                 qDebug() << "testDataChanged: " << itemIndex;
             //    switch (itemIndex) {
             //    case 0: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 20; x++) {
             //            data.append(QChartDataPoint() << x << x / 2);
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 1: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 100; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 2: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 1000; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    default:
             //        break;
             //    }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chartWidget->setChartTheme((QChart::ChartTheme) themeIndex);
                 //TODO: remove this hack. This is just to make it so that theme change is seen immediately.
                 QSize s = size();
                 s.setWidth(s.width()+1);
                 resize(s);
             }
             void MainWidget::setPieSizeFactor(double size)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setSizeFactor(qreal(size));
             }
             void MainWidget::setPiePosition(int position)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setPosition((QPieSeries::PiePosition) position);
             }

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