HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r357:82b904eaae07

review fix: Removed iterator from barseries. Remove const from brush and pen. Renamed setters for tooltip, floating values and separators

sauimone -

r357:82b904eaae07

parent child

Context file:

r357:82b904eaae07

Collapse all files

example/barchart/main.cpp +1 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 //! [1]
                 // Create category
                 QBarCategory *category = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 //! [1]
                 //! [2]
                 // Create some test sets for chat
                 QBarSet *set0 = new QBarSet("Bub");
                 QBarSet *set1 = new QBarSet("Bob");
                 QBarSet *set2 = new QBarSet("Guybrush");
                 QBarSet *set3 = new QBarSet("Larry");
                 QBarSet *set4 = new QBarSet("Zak");
                 *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;
                 *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;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
                 //! [2]
                 //! [3]
                 // Create series and add sets to it
                 QBarSeries* series= new QBarSeries(category);
                 series->addBarSet(set0);
                 series->addBarSet(set1);
                 series->addBarSet(set2);
                 series->addBarSet(set3);
                 series->addBarSet(set4);
                 //! [3]
                 //! [4]
                 // Enable some features
-                series->enableToolTip();
+                series->setToolTipEnabled();
                 series->enableFloatingValues();
                 //! [4]
                 //! [5]
                 // Create view for chart and add series to it. Apply theme.
                 QChartView* chartView =  new QChartView(&window);
                 chartView->addSeries(series);
                 chartView->setChartTitle("simple stacked barchart");
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 //! [5]
                 window.setCentralWidget(chartView);
                 window.resize(600, 300);
                 window.show();
                 return a.exec();
             }

example/percentbarchart/main.cpp +1 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <qpercentbarseries.h>
             #include <qbarcategory.h>
             #include <qchartview.h>
             #include <qbarset.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 //! [1]
                 // Create category
                 QBarCategory *category = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 //! [1]
                 //! [2]
                 // Create some test sets for chat
                 QBarSet *set0 = new QBarSet("Bub");
                 QBarSet *set1 = new QBarSet("Bob");
                 QBarSet *set2 = new QBarSet("Guybrush");
                 QBarSet *set3 = new QBarSet("Larry");
                 QBarSet *set4 = new QBarSet("Zak");
                 *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;
                 *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;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
                 //! [2]
                 //! [3]
                 // Create series and add sets to it
                 QPercentBarSeries* series = new QPercentBarSeries(category);
                 series->addBarSet(set0);
                 series->addBarSet(set1);
                 series->addBarSet(set2);
                 series->addBarSet(set3);
                 series->addBarSet(set4);
                 //! [3]
                 //! [4]
                 // Enable features
-                series->enableToolTip();
+                series->setToolTipEnabled();
                 series->enableFloatingValues();
                 //! [4]
                 //! [5]
                 // Create view for chart and add series to it. Apply theme.
                 QChartView* chartView =  new QChartView(&window);
                 chartView->addSeries(series);
                 chartView->setChartTitle("simple percent barchart");
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 //! [5]
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/stackedbarchart/main.cpp +1 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 //! [1]
                 // Create category
                 QBarCategory *category = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 //! [1]
                 //! [2]
                 // Create some test sets for chat
                 QBarSet *set0 = new QBarSet("Bub");
                 QBarSet *set1 = new QBarSet("Bob");
                 QBarSet *set2 = new QBarSet("Guybrush");
                 QBarSet *set3 = new QBarSet("Larry");
                 QBarSet *set4 = new QBarSet("Zak");
                 *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;
                 *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;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
                 //! [2]
                 //! [3]
                 // Create series and add sets to it
                 QStackedBarSeries* series = new QStackedBarSeries(category);
                 series->addBarSet(set0);
                 series->addBarSet(set1);
                 series->addBarSet(set2);
                 series->addBarSet(set3);
                 series->addBarSet(set4);
                 //! [3]
                 //! [4]
                 // Enable features
-                series->enableToolTip();
+                series->setToolTipEnabled();
                 series->enableFloatingValues();
                 //! [4]
                 //! [5]
                 // Create view for chart and add series to it. Apply theme.
                 QChartView* chartView =  new QChartView(&window);
                 chartView->addSeries(series);
                 chartView->setChartTitle("simple stacked barchart");
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 //! [5]
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/barchart/barchartmodel.cpp +4 -14

             #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) :
                 QObject(parent)
                 ,mCategory(category)
             {
             }
             BarChartModel::~BarChartModel()
             {
                 delete mCategory;
             }
             QBarCategory& 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::nextSet(bool getFirst)
+            QBarSet* BarChartModel::setAt(int index)
             {
-                if (getFirst) {
+                return mDataModel.at(index);
-                    mCurrentSet = 0;
-                if ((mDataModel.count() <= 0) || (mDataModel.count() <= mCurrentSet)) {
-                    return 0;
-                QBarSet* set = mDataModel.at(mCurrentSet);
-                mCurrentSet++;
-                return set;
             }
-            QBarSet* BarChartModel::setAt(int index)
+            QList<QBarSet*> BarChartModel::barSets()
             {
-                return mDataModel.at(index);
+                return mDataModel;
             }
             QList<QString> BarChartModel::legend()
             {
                 QList<QString> legend;
                 for (int i=0; i<mDataModel.count(); i++) {
                     legend.append(mDataModel.at(i)->name());
                 }
                 return legend;
             }
             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::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 = 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);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +2 -1

             #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);
                 ~BarChartModel();
                 QBarCategory& category();
                 void addBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
-                QBarSet* nextSet(bool getFirst);
                 QBarSet *setAt(int index);
+                QList<QBarSet*> barSets();
                 QList<QString> legend();
                 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 percentageAt(int set, int category);
                 qreal categorySum(int category);
                 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;    // Owned
                 int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barpresenter.cpp +1 -1

             #include "barpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenter::BarPresenter(QBarSeries *series, QGraphicsItem *parent) :
                 BarPresenterBase(series, parent)
             {
                 mBarDefaultWidth = 15;
             }
             void BarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarPresenter::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 categoryCount = mSeries->countCategories();
                 int setCount = mSeries->countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mSeries->max();
                 qreal scale = (tH/tM);
                 qreal tC = categoryCount+1;
                 qreal xStepPerSet = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
                 int labelIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mSeries->setAt(set)->brush());
+                        bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     qreal yPos = mHeight;
                     for (int set=0; set < mSeries->countSets(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                 }
                 mLayoutDirty = true;
             }
             #include "moc_barpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.cpp +2 -2

             #include "barpresenterbase.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "barlabel_p.h"
             #include "separator_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";
                 // 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->countCategories(); c++) {
                     for (int s=0; s<mSeries->countSets(); s++) {
-                        QBarSet *set = mSeries->setAt(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(hoverEntered(QPoint)),set,SLOT(barHoverEntered(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaved()));
                     }
                 }
                 // Create labels
                 int count = mSeries->countCategories();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     label->set(mSeries->label(i));
                     childItems().append(label);
                     mLabels.append(label);
                 }
                 // Create separators
                 count = mSeries->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
                     sep->setVisible(mSeparatorsEnabled);
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->countCategories(); category++) {
                     for (int s=0; s<mSeries->countSets(); s++) {
-                        QBarSet *set = mSeries->setAt(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.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarpresenter.cpp +1 -1

             #include "percentbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarPresenter::PercentBarPresenter(QBarSeries *series, QGraphicsItem *parent) :
                 BarPresenterBase(series, parent)
             {
             }
             void PercentBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: PercentBarPresenter::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 = mSeries->countCategories();
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 qreal h = mHeight;
                 for (int category = 0; category < mSeries->countCategories(); category++) {
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int set=0; set < mSeries->countSets(); set++) {
                         qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mSeries->setAt(set)->brush());
+                        bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 xPos = xStep + xStep/2;
                 for (int s=0; s < mSeries->countCategories() - 1; s++) {
                     Separator* sep = mSeparators.at(s);
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     for (int set=0; set < mSeries->countSets(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         if (mSeries->valueAt(set,category) != 0) {
                             int p = mSeries->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             value->setValueString(vString);
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             #include "moc_percentbarpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +9 -29

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             #include "barchartmodel_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 QBarCategory class.
                 \mainclass
-                Example on how to create category:
-                \snippet ../example/barchart/main.cpp 1
-                Example on how to create sets of data:
-                \snippet ../example/barchart/main.cpp 2
-                Example on how to add sets to bar chart:
-                \snippet ../example/barchart/main.cpp 3
-                Example on how to enable tooltip and floating values:
-                \snippet ../example/barchart/main.cpp 4
-                Example on how to create view and apply theme:
-                \snippet ../example/barchart/main.cpp 5
                 \sa QBarCategory, QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QChartSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QChartSeries, QChartSeriesType
             */
             /*!
                 \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 category defines the categories for chart.
                 Takes ownership of \a category.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategory *category, QObject *parent)
                 : QChartSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
             /*!
                 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::countSets()
             {
                 return mModel->countSets();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             /*!
-                Simple iterator for set. Returns pointer to next set in series.
+                Returns a list of sets in series. Keeps ownership of sets.
-                Returns first set, if parameter \a getFirst is true.
+             */
-                If series is empty, returns 0.
+            QList<QBarSet*> QBarSeries::barSets()
-                Returns 0 after last set.
-            */
-            QBarSet* QBarSeries::nextSet(bool getFirst)
             {
-                return mModel->nextSet(getFirst);
+                return mModel->barSets();
             }
             /*!
-                Returns set indexed by \a index. Doesn't check for index bounds.
+                \internal \a index
-                Assumes that \a index is between 0 and number of sets. Use countSets() to get valid index bound.
-                \sa countSets()
             */
-            QBarSet* QBarSeries::setAt(int index)
+            QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 Returns legend of series. Legend is a list of set names in series.
             */
             QList<QString> QBarSeries::legend()
             {
                 return mModel->legend();
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::label(int category)
             {
                 return mModel->label(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::enableFloatingValues(bool enabled)
+            void QBarSeries::setFloatingValuesEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(clicked()),set,SIGNAL(toggleFloatingValues()));
                     }
                 } else {
                     for (int i=0; i<mModel->countSets(); 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::enableToolTip(bool enabled)
+            void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->countSets(); 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::enableSeparators(bool enabled)
+            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;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +5 -5

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QBarCategory *category, QObject* parent=0);
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int countSets();
                 int countCategories();
-                QBarSet* nextSet(bool getFirst=false);      // Returns first set, if called with true
+                QList<QBarSet*> barSets();
-                QBarSet *setAt(int index);
                 QList<QString> legend();                    // Returns legend of series (ie. names of all sets in series)
             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);
                 QString label(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();
                 // <--- TO PIMPL
             signals:
                 void changed(int index);
                 // 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 enableFloatingValues(bool enabled=true);    // enables floating values on top of bars
+                void setFloatingValuesEnabled(bool enabled=true);    // enables floating values on top of bars
-                void enableToolTip(bool enabled=true);           // enables tooltips
+                void setToolTipEnabled(bool enabled=true);           // enables tooltips
-                void enableSeparators(bool enabled=true);        // enables separators between categories
+                void setSeparatorsEnabled(bool enabled=true);        // enables separators between categories
             protected:
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +4 -4

             #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
                 Example on how to create sets of data:
                 \snippet ../example/barchart/main.cpp 2
                 \sa QBarCategory, 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(const QPen& pen)
+            void QBarSet::setPen(QPen pen)
             {
                 mPen = pen;
             }
             /*!
                 Returns pen of the set.
             */
-            const QPen& QBarSet::pen() const
+            QPen QBarSet::pen()
             {
                 return mPen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
-            void QBarSet::setBrush(const QBrush& brush)
+            void QBarSet::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             /*!
                 Returns brush of the set.
             */
-            const QBrush& QBarSet::brush() const
+            QBrush QBarSet::brush()
             {
                 return mBrush;
             }
             /*!
                 \internal
             */
             void QBarSet::barClicked()
             {
             //    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)
             {
                 emit showToolTip(pos, mName);
                 emit hoverEnter(pos);
             }
             /*!
                 \internal
             */
             void QBarSet::barHoverLeaved()
             {
             //    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 +4 -4

             #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(const QPen& pen);
+                void setPen(QPen pen);
-                const QPen& pen() const;
+                QPen pen();
-                void setBrush(const QBrush& brush);
+                void setBrush(QBrush brush);
-                const QBrush& brush() const;
+                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 barHoverEntered(QPoint pos);
                 void barHoverLeaved();
                 // <--- TO PIMPL
             private:
                 QString mName;
                 QList<qreal> mValues;
                 QPen mPen;
                 QBrush mBrush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarpresenter.cpp +1 -1

             #include "stackedbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarPresenter::StackedBarPresenter(QBarSeries *series, QGraphicsItem *parent) :
                 BarPresenterBase(series,parent)
             {
             }
             void StackedBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mSeries->countCategories() == 0) {
                     qDebug() << "No categories in model!";
                     // Nothing to do
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: StackedBarPresenter::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 category count...
                 qreal maxSum = mSeries->maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
                 qreal tC = mSeries->countCategories() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category = 0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->countSets(); set++) {
                         qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mSeries->setAt(set)->brush());
+                        bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 xPos = xStep + xStep/2;
                 for (int s=0; s < mSeries->countCategories() - 1; s++) {
                     Separator* sep = mSeparators.at(s);
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->countSets(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             #include "moc_stackedbarpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +6 -3

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "scatterpresenter_p.h"
             #include "piepresenter_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
+                QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
-                    series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
+                    sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
+                QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
-                    series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
+                    sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
+                QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
-                    series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
+                    sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

test/chartwidgettest/mainwidget.cpp +1 -1

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include <qlineseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.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);
             }
             // 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, int, int, QString, bool)),
                         this, SLOT(addSeries(QString, int, int, QString, bool)));
                 dialog.exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 5);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName.contains("line", Qt::CaseInsensitive)) {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         for (int i(0); i < column.count(); i++) {
                             series->add(i, column.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName.contains("scatter", Qt::CaseInsensitive)) {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         for (int i(0); i < column.count(); i++) {
                            (*series) << QPointF(i, column.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName.contains("pie", Qt::CaseInsensitive)) {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++) {
                             series->add(column.at(i), labels.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     // TODO: replace QBarCategory with QStringList?
                     QBarCategory *category = new QBarCategory;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         *category << label;
                     QBarSeries* series = 0;
                     if (seriesName == "Bar")
                         series = new QBarSeries(category, this);
                     else if (seriesName == "Stacked bar")
                         series = new QStackedBarSeries(category, this);
                     else
                         series = new QPercentBarSeries(category, this);
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++) {
                             *set << column.at(i);
                         }
                         series->addBarSet(set);
                     }
                     series->enableFloatingValues();
-                    series->enableToolTip();
+                    series->setToolTipEnabled();
                     series->enableSeparators(false);
                     m_chartWidget->addSeries(series);
                     setCurrentSeries(series);
                 }
                 // TODO: spline and area
             }
             void MainWidget::setCurrentSeries(QChartSeries *series)
             {
                 if (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::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