HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r216:abacdc3682d1

Common naming convention for barcharts

sauimone -

r216:abacdc3682d1

parent child

Context file:

r216:abacdc3682d1

Expand all files

example/barchart/main.cpp +2 -2

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
-            #include <barchartseries.h>
+            #include <qbarchartseries.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 = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
-                BarChartSeries* series0 = new BarChartSeries(category);
+                QBarChartSeries* series0 = new QBarChartSeries(category);
                 QBarSet *set0 = new QBarSet;
                 QBarSet *set1 = new QBarSet;
                 QBarSet *set2 = new QBarSet;
                 QBarSet *set3 = new QBarSet;
                 QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
                 *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;
                 series0->addBarSet(set0);
                 series0->addBarSet(set1);
                 series0->addBarSet(set2);
                 series0->addBarSet(set3);
                 series0->addBarSet(set4);
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->addSeries(series0);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/gdpbarchart/widget.cpp +2 -2

             #include "widget.h"
             #include <QGridLayout>
             #include <QPushButton>
             #include <QLabel>
             #include <QSqlQuery>
             #include <qscatterseries.h>
             #include <qchartview.h>
             #include <qchartaxis.h>
-            #include <barchartseries.h>
+            #include <qbarchartseries.h>
             #include <qbarcategory.h>
             #include <qbarset.h>
             #include <QListWidget>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Widget::Widget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 800, 600);
                 // right panel layout
                 countrieslist = new QListWidget;
                 countrieslist->setSelectionMode(QAbstractItemView::MultiSelection);
                 yearslist = new QListWidget;
                 yearslist->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 for (int i = 1990; i < 2011; i++)
                     yearslist->addItem(QString("%1").arg(i));
                 QPushButton* refreshButton = new QPushButton(tr("Refresh"));
                 connect(refreshButton, SIGNAL(clicked()), this, SLOT(refreshChart()));
                 QVBoxLayout* rightPanelLayout = new QVBoxLayout;
                 rightPanelLayout->addWidget(countrieslist);
                 rightPanelLayout->addWidget(yearslist);
                 rightPanelLayout->addWidget(refreshButton);
                 rightPanelLayout->setStretch(0, 1);
                 rightPanelLayout->setStretch(1, 0);
                 // main layout
                 chartArea = new QChartView(this);
                 chartArea->setChartTitle("GDP by country");
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chartArea, 0, 0);
                 mainLayout->addLayout(rightPanelLayout, 0, 1);
                 mainLayout->setColumnStretch(0,1);
                 setLayout(mainLayout);
                 // connect to the database
                 db = QSqlDatabase::addDatabase("QSQLITE");
                 db.setDatabaseName("gdpData");
                 if(!db.open())
                 {
                     qDebug() << "could not open database. SQLite db file missing (?)";
                     return;
                 }
                 // get the list of all countires and regions.
                 QSqlQuery query;
                 query.exec("SELECT DISTINCT country FROM gdp2");
                 // add the countries to the country filter
                 while (query.next()) {
                     countrieslist->addItem(query.value(0).toString());
                 }
                 // hide axis X labels
                 QChartAxis newAxis = chartArea->defaultAxisX();
                 newAxis.setLabelsVisible(false);
             //    newAxis.setLabelsOrientation(QChartAxis::LabelsOrientationSlide);
                 chartArea->setDefaultAxisX(newAxis);
             }
             Widget::~Widget()
             {
                 //
                 db.close();
             }
             void Widget::refreshChart()
             {
                 // selected countries items list is not sorted. copy the values to QStringlist and sort them.
                 QStringList selectedCountriesStrings;
                 QList<QListWidgetItem*> selectedCountriesItems = countrieslist->selectedItems();
                 for (int i = 0; i < selectedCountriesItems.size(); i++)
                     selectedCountriesStrings.append(selectedCountriesItems[i]->text());
                 selectedCountriesStrings.sort();
                 // use the sorted selected coutries list to initialize BarCategory
                 QBarCategory* category = new QBarCategory;
                 for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     *category << selectedCountriesStrings[i];
-                BarChartSeries* series0 = new BarChartSeries(category);
+                QBarChartSeries* series0 = new QBarChartSeries(category);
                 // prepare the selected counries SQL query
                 QString countriesQuery = "country IN (";
                 for (int i = 0; i < selectedCountriesStrings.size(); i++)
                 {
                     countriesQuery.append("'" + selectedCountriesStrings[i] + "'");
                     if ( i < selectedCountriesStrings.size() - 1)
                         countriesQuery.append(",");
                     else
                         countriesQuery.append(")");
                 }
                 QSqlQuery query;
                 // selected years items list is not sorted. copy the values to QList<Integer> and sort them.
                 QList<int> selectedYearsInts;
                 QList<QListWidgetItem*> selectedYearsItems = yearslist->selectedItems();
                 for (int i = 0; i < selectedYearsItems.size(); i++)
                     selectedYearsInts.append(selectedYearsItems[i]->text().toInt());
                 qSort(selectedYearsInts);
                 // perform a query for each selected year
                 for (int i = 0; i < selectedYearsInts.size(); i++)
                 {
                     query.exec("SELECT country,gdpvalue FROM gdp2 where year=" + QString("%1").arg(selectedYearsInts[i]) + " AND " + countriesQuery);
                     QBarSet* barSet = new QBarSet;
             //        while (query.next()) {
             //            qDebug() << query.value(0).toString() << " : " << query.value(1).toString();
             //        }
                     query.first();
                     // the data for some of the coutries for some years might be missing.
                     // QBarChart needs bars to have same size
                     for (int k = 0; k < selectedCountriesStrings.size(); k++)
                     {
                         if (selectedCountriesStrings[k] == query.value(0).toString())
                         {
                             *barSet << query.value(1).toReal();
                             qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[i]);
                             query.next();
                         }
                         else
                         {
                             // data missing, put 0
                             *barSet << 0.0f;
                             qDebug() << "Putting 0 for Bosnia" << " : " << QString("%1").arg(selectedYearsInts[i]);
                         }
                     }
                     series0->addBarSet(barSet);
                 }
                 // add the serie to the chart
                 chartArea->addSeries(series0);
             }

example/percentbarchart/main.cpp +2 -2

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
-            #include <percentbarchartseries.h>
+            #include <qpercentbarchartseries.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 = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
-                PercentBarChartSeries* series0 = new PercentBarChartSeries(category);
+                QPercentBarChartSeries* series0 = new QPercentBarChartSeries(category);
                 QBarSet *set0 = new QBarSet;
                 QBarSet *set1 = new QBarSet;
                 QBarSet *set2 = new QBarSet;
                 QBarSet *set3 = new QBarSet;
                 QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
                 *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;
                 series0->addBarSet(set0);
                 series0->addBarSet(set1);
                 series0->addBarSet(set2);
                 series0->addBarSet(set3);
                 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 +2 -2

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
-            #include <stackedbarchartseries.h>
+            #include <qstackedbarchartseries.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 = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
-                StackedBarChartSeries* series0 = new StackedBarChartSeries(category);
+                QStackedBarChartSeries* series0 = new QStackedBarChartSeries(category);
                 QBarSet *set0 = new QBarSet;
                 QBarSet *set1 = new QBarSet;
                 QBarSet *set2 = new QBarSet;
                 QBarSet *set3 = new QBarSet;
                 QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
                 *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;
                 series0->addBarSet(set0);
                 series0->addBarSet(set1);
                 series0->addBarSet(set2);
                 series0->addBarSet(set3);
                 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/barpresenter.cpp ~~src/barchart/bargroup.cpp~~ renamed +4 -4

-            #include "bargroup.h"
+            #include "barpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarGroup::BarGroup(BarChartModel& model, QGraphicsItem *parent) :
+            BarPresenter::BarPresenter(BarChartModel& model, QGraphicsItem *parent) :
-                BarGroupBase(model,parent)
+                BarPresenterBase(model,parent)
             {
                 mBarDefaultWidth = 5;
             }
-            void BarGroup::layoutChanged()
+            void BarPresenter::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 setCount = mModel.countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mModel.max();
                 qreal scale = (tH/tM);
                 qreal tC = itemCount+1;
                 qreal xStepPerSet = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
                 int labelIndex = itemCount * setCount;
                 for (int item=0; item < itemCount; item++) {
                     qreal xPos = xStepPerSet * item + ((tW + mBarDefaultWidth*setCount)/(itemCount*2));
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mModel.valueAt(set, item) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setBrush(mModel.setAt(set).brush());
                         bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + set * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerSet * item + ((tW + mBarDefaultWidth*setCount)/(itemCount*2));
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenter.h ~~src/barchart/bargroup.h~~ renamed +4 -4

             #ifndef QBARGROUP_H
             #define QBARGROUP_H
-            #include "bargroupbase.h"
+            #include "barpresenterbase.h"
-            #include "barchartseries.h"
+            #include "qbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Base class for bar groups
-            class BarGroup : public BarGroupBase
+            class BarPresenter : public BarPresenterBase
             {
             public:
-                explicit BarGroup(BarChartModel& model, QGraphicsItem *parent = 0);
+                explicit BarPresenter(BarChartModel& model, QGraphicsItem *parent = 0);
             private:
                 // From BarGroupBase
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARGROUP_H

src/barchart/barpresenterbase.cpp ~~src/barchart/bargroupbase.cpp~~ renamed +11 -11

-            #include "bargroupbase.h"
+            #include "barpresenterbase.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarGroupBase::BarGroupBase(BarChartModel& model, QGraphicsItem *parent)
+            BarPresenterBase::BarPresenterBase(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)
             {
                 dataChanged();
             }
-            void BarGroupBase::setSeparatorsVisible(bool visible)
+            void BarPresenterBase::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
             }
-            void BarGroupBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+            void BarPresenterBase::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
+            QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
-            void BarGroupBase::setBarWidth( int w )
+            void BarPresenterBase::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             /*
             void BarGroupBase::resetBrushes()
             {
                 mBrushes.clear();
             }
             void BarGroupBase::addBrush(QBrush brush)
             {
                 mBrushes.append(brush);
             }
             */
-            void BarGroupBase::dataChanged()
+            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?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mModel.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 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;   // 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)
+            void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarGroupBase::handleModelChanged" << index;
                 dataChanged();
             }
-            void BarGroupBase::handleDomainChanged(const Domain& domain)
+            void BarPresenterBase::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)
+            void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
-            #include "moc_bargroupbase.cpp"
+            #include "moc_barpresenterbase.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.h ~~src/barchart/bargroupbase.h~~ renamed +2 -2

             #ifndef BARGROUPBASE_H
             #define BARGROUPBASE_H
             #include "chartitem_p.h"
             #include "barchartmodel_p.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Base Class for bar groups. Common implemantation of different groups. Not to be instantiated.
-            class BarGroupBase : public QObject, public ChartItem
+            class BarPresenterBase : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
-                BarGroupBase(BarChartModel& model, QGraphicsItem *parent = 0);
+                BarPresenterBase(BarChartModel& model, QGraphicsItem *parent = 0);
                 void setSeparatorsVisible(bool visible = true);
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: these may change with layout awarness.
                 void setBarWidth( int w );
             //    void resetBrushes();
             //    void addBrush(QBrush brush);
                 void setPen(QPen pen);
                 QPen pen();
                 void setBrush(QBrush brush);
                 QBrush brush();
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 virtual void layoutChanged() = 0;   // layout has changed -> need to recalculate bar sizes
             protected slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
                 bool mSeparatorsVisible;
                 BarChartModel& mModel;
                 QPen mPen;
             //    QList<QBrush> mBrushes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARGROUPBASE_H

src/barchart/percentbarpresenter.cpp ~~src/barchart/percentbargroup.cpp~~ renamed +4 -4

-            #include "percentbargroup.h"
+            #include "percentbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarGroup::PercentBarGroup(BarChartModel& model, QGraphicsItem *parent) :
+            PercentBarPresenter::PercentBarPresenter(BarChartModel& model, QGraphicsItem *parent) :
-                BarGroupBase(model, parent)
+                BarPresenterBase(model, parent)
             {
             }
-            void PercentBarGroup::layoutChanged()
+            void PercentBarPresenter::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 category = 0; category < mModel.countCategories(); category++) {
                     qreal colSum = mModel.categorySum(category);
                     qreal h = mHeight;
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setBrush(mModel.setAt(set).brush());
                         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/percentbarpresenter.h ~~src/barchart/percentbargroup.h~~ renamed +4 -4

             #ifndef PERCENTBARGROUP_H
             #define PERCENTBARGROUP_H
             #include "chartitem_p.h"
             #include "bar_p.h"
-            #include "percentbarchartseries.h"
+            #include "qpercentbarchartseries.h"
-            #include "bargroupbase.h"
+            #include "barpresenterbase.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class PercentBarGroup : public BarGroupBase
+            class PercentBarPresenter : public BarPresenterBase
             {
             public:
-                PercentBarGroup(BarChartModel& model, QGraphicsItem *parent = 0);
+                PercentBarPresenter(BarChartModel& model, QGraphicsItem *parent = 0);
             private:
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARGROUP_H

src/barchart/qbarchartseries.cpp ~~src/barchart/barchartseries.cpp~~ renamed +13 -13

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

src/barchart/qbarchartseries.h ~~src/barchart/barchartseries.h~~ renamed +4 -4

             #ifndef BARCHARTSERIES_H
             #define BARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QBarSet;
-            class BarGroup;
+            class BarPresenter;
             class BarChartModel;
             // Container for series
-            class QTCOMMERCIALCHART_EXPORT BarChartSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                BarChartSeries(QBarCategory *category, QObject* parent=0);
+                QBarChartSeries(QBarCategory *category, QObject* parent=0);
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);       // Takes ownership of set
                 void removeBarSet(QBarSet *set);    // Removes set, releases ownership.
                 int countSets();
                 QBarSet* nextSet(bool getFirst=false);     // Returns first set, if called with true
                 //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;
+                BarPresenter* mBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTSERIES_H

src/barchart/qpercentbarchartseries.cpp ~~src/barchart/stackedbarchartseries.cpp~~ renamed +14 -14

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

src/barchart/qpercentbarchartseries.h ~~src/barchart/percentbarchartseries.h~~ renamed +4 -4

             #ifndef PERCENTBARCHARTSERIES_H
             #define PERCENTBARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class PercentBarGroup;
+            class PercentBarPresenter;
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
-            class QTCOMMERCIALCHART_EXPORT PercentBarChartSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QPercentBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                PercentBarChartSeries(QBarCategory *category, QObject* parent=0);
+                QPercentBarChartSeries(QBarCategory *category, QObject* parent=0);
                 // from BarChartSeriesBase
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypePercentBar; }
                 void addBarSet(QBarSet *set);       // Takes ownership
                 void removeBarSet(QBarSet *set);    // Also deletes the set, if set is owned.
                 int countSets();
                 QBarSet* nextSet(bool first=false);     // Returns first set, if called with true
                 //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;
+                PercentBarPresenter* mPercentBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARCHARTSERIES_H

src/barchart/qstackedbarchartseries.cpp ~~src/barchart/percentbarchartseries.cpp~~ renamed +14 -16

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

src/barchart/qstackedbarchartseries.h ~~src/barchart/stackedbarchartseries.h~~ renamed +4 -4

             #ifndef STACKEDBARCHARTSERIES_H
             #define STACKEDBARCHARTSERIES_H
             #include <QList>
             #include <QAbstractItemModel>
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class StackedBarGroup;
+            class StackedBarPresenter;
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
-            class QTCOMMERCIALCHART_EXPORT StackedBarChartSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QStackedBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                StackedBarChartSeries(QBarCategory *category, QObject* parent=0);
+                QStackedBarChartSeries(QBarCategory *category, QObject* parent=0);
                 // from QChartSeries
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeStackedBar; }
                 void addBarSet(QBarSet *set);       // Takes ownership
                 void removeBarSet(QBarSet *set);    // Also deletes the set, if set is owned.
                 int countSets();
                 QBarSet* nextSet(bool first=false);     // Returns first set, if called with true
                 //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;
+                StackedBarPresenter* mStackedBarGroup;
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARCHARTSERIES_H

src/barchart/stackedbarpresenter.cpp ~~src/barchart/stackedbargroup.cpp~~ renamed +4 -4

-            #include "stackedbargroup.h"
+            #include "stackedbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarGroup::StackedBarGroup(BarChartModel& model, QGraphicsItem *parent) :
+            StackedBarPresenter::StackedBarPresenter(BarChartModel& model, QGraphicsItem *parent) :
-                BarGroupBase(model,parent)
+                BarPresenterBase(model,parent)
             {
             }
-            void StackedBarGroup::layoutChanged()
+            void StackedBarPresenter::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 category 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 category = 0; category < mModel.countCategories(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setBrush(mModel.setAt(set).brush());
                         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/stackedbarpresenter.h ~~src/barchart/stackedbargroup.h~~ renamed +4 -4

             #ifndef STACKEDBARGROUP_H
             #define STACKEDBARGROUP_H
-            #include "bargroupbase.h"
+            #include "barpresenterbase.h"
-            #include "stackedbarchartseries.h"
+            #include "qstackedbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class StackedBarGroup : public BarGroupBase
+            class StackedBarPresenter : public BarPresenterBase
             {
             public:
-                StackedBarGroup(BarChartModel& model, QGraphicsItem *parent = 0);
+                StackedBarPresenter(BarChartModel& model, QGraphicsItem *parent = 0);
             private:
                 // From BarGroupBase
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARGROUP_H

src/chartdataset.cpp +6 -6

             #include "chartdataset_p.h"
             //series
             #include "qlinechartseries.h"
-            #include "barchartseries.h"
+            #include "qbarchartseries.h"
-            #include "stackedbarchartseries.h"
+            #include "qstackedbarchartseries.h"
-            #include "percentbarchartseries.h"
+            #include "qpercentbarchartseries.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;
                 series->setParent(this); // take ownership
                 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);
+                        QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(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);
+                        QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(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);
+                        QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(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 +12 -12

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
-            #include "barchartseries.h"
+            #include "qbarchartseries.h"
-            #include "stackedbarchartseries.h"
+            #include "qstackedbarchartseries.h"
-            #include "percentbarchartseries.h"
+            #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
-            #include "bargroup.h"
+            #include "barpresenter.h"
-            #include "stackedbargroup.h"
+            #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
-            #include "percentbargroup.h"
+            #include "percentbarpresenter.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_axisXItem(new AxisItem(AxisItem::X_AXIS,m_chart)),
             m_axisYItem(new AxisItem(AxisItem::Y_AXIS,m_chart)),
             m_domainIndex(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 setChartTheme(QChart::ChartThemeDefault);
                 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*)));
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisXItem,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisXItem,SLOT(handleDomainChanged(const Domain&)));
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisYItem,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisYItem,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);
+                        QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(series);
-                        BarGroup* item = new BarGroup(barSeries->model(),m_chart);
+                        BarPresenter* item = new BarPresenter(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);
+                        QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(series);
-                        StackedBarGroup* item = new StackedBarGroup(stackedBarSeries->model(),m_chart);
+                        StackedBarPresenter* item = new StackedBarPresenter(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);
+                        QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(series);
-                        PercentBarGroup* item = new PercentBarGroup(percentBarSeries->model(),m_chart);
+                        PercentBarPresenter* item = new PercentBarPresenter(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&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         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);
                 }
                 m_chartTheme->decorate(m_axisX, m_axisXItem);
                 m_chartTheme->decorate(m_axisY, m_axisYItem);
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setDefaultAxisX(const QChartAxis& axis)
             {
                 //if(m_axisX != axis) {
                     m_axisX = axis;
                     m_axisXItem->handleAxisChanged(m_axisX);
                 //}
             }
             void ChartPresenter::setDefaultAxisY(const QChartAxis& axis)
             {
                 // if(m_axisY != axis) {
                     m_axisY = axis;
                     m_axisYItem->handleAxisChanged(m_axisY);
                 //}
             }
             QChartAxis ChartPresenter::defaultAxisX() const
             {
                 return m_axisX;
             }
             QChartAxis ChartPresenter::defaultAxisY() const
             {
                 return m_axisY;
             }
             QChartAxis ChartPresenter::axisY(int id) const
             {
                 return m_axis.value(id);
             }
             int ChartPresenter::addAxisY(const QChartAxis& axis)
             {
                 int key =0 ;
                 while(m_axis.contains(key)){
                     key++;
                     //TODO overflow
                 }
                 m_axis.insert(key,axis);
                 m_axisItems.insert(key,new AxisItem(AxisItem::Y_AXIS,m_chart));
                 return key;
             }
             void ChartPresenter::removeAxisY(int id)
             {
                 m_axis.remove(id);
                 delete m_axisItems.take(id);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +15 -15

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "qbarset.h"
-            #include "barchartseries.h"
+            #include "qbarchartseries.h"
-            #include "stackedbarchartseries.h"
+            #include "qstackedbarchartseries.h"
-            #include "percentbarchartseries.h"
+            #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
-            #include "bargroup.h"
+            #include "barpresenter.h"
-            #include "stackedbargroup.h"
+            #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
-            #include "percentbargroup.h"
+            #include "percentbarpresenter.h"
             #include "scatterpresenter_p.h"
             #include "piepresenter.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));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     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: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
-                        BarChartSeries* b = static_cast<BarChartSeries*>(series);
+                        QBarChartSeries* b = static_cast<QBarChartSeries*>(series);
-                        BarGroup* i = static_cast<BarGroup*>(item);
+                        BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
-                        StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
+                        QStackedBarChartSeries* s = static_cast<QStackedBarChartSeries*>(series);
-                        StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
+                        StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
-                        PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
+                        QPercentBarChartSeries* s = static_cast<QPercentBarChartSeries*>(series);
-                        PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
+                        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, QLineChartSeries* 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(BarGroup* item, BarChartSeries* series,int count)
+            void ChartTheme::decorate(BarPresenter* item, QBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
-            void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
+            void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
-            void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
+            void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==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, 1);
                 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();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     s->setPen(QPen(Qt::black)); // TODO: get from theme
                     s->setBrush(colors.takeFirst());
                 }
             }
             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);
                 item->handleAxisChanged(axis);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +9 -9

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class LineChartItem;
             class QLineChartSeries;
-            class BarGroup;
+            class BarPresenter;
-            class BarChartSeries;
+            class QBarChartSeries;
-            class StackedBarGroup;
+            class StackedBarPresenter;
-            class StackedBarChartSeries;
+            class QStackedBarChartSeries;
-            class PercentBarChartSeries;
+            class QPercentBarChartSeries;
-            class PercentBarGroup;
+            class PercentBarPresenter;
             class QScatterSeries;
             class ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
             class ChartTheme
             {
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(ChartItem* item, QChartSeries* series,int count);
                 void decorate(LineChartItem* item, QLineChartSeries*, int count);
-                void decorate(BarGroup* item, BarChartSeries* series,int count);
+                void decorate(BarPresenter* item, QBarChartSeries* series,int count);
-                void decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count);
+                void decorate(StackedBarPresenter* item, QStackedBarChartSeries* series,int count);
-                void decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count);
+                void decorate(PercentBarPresenter* item, QPercentBarChartSeries* series,int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis& axis,AxisItem* item);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/qchart.cpp +3 -3

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
-            #include "barchartseries.h"
+            #include "qbarchartseries.h"
-            #include "stackedbarchartseries.h"
+            #include "qstackedbarchartseries.h"
-            #include "percentbarchartseries.h"
+            #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             //#include "scatterseries_p.h"
             #include "qpieseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series)
             {
                 m_dataset->addSeries(series);
             }
             //TODO on review, is it really needed ??
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 QChartSeries *series(0);
                 switch (type) {
                     case QChartSeries::SeriesTypeLine: {
                         series = new QLineChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         //series = new BarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         //series = new StackedBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         //series = new PercentBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         series = new QScatterSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         series = new QPieSeries(this);
                         break;
                     }
                     default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setChartTitle(const QString& title)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
             }
             void QChart::setChartTitleFont(const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 m_presenter->zoomInToRect(rectangle);
             }
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             void QChart::setDefaultAxisX(const QChartAxis& axis)
             {
                 m_presenter->setDefaultAxisX(axis);
             }
             void QChart::setDefaultAxisY(const QChartAxis& axis)
             {
                 m_presenter->setDefaultAxisY(axis);
             }
             QChartAxis QChart::defaultAxisX() const
             {
                 return m_presenter->defaultAxisX();
             }
             QChartAxis QChart::defaultAxisY() const
             {
                 return m_presenter->defaultAxisY();
             }
             int QChart::addAxisY(const QChartAxis& axis)
             {
                 return m_presenter->addAxisY(axis);
             }
             QChartAxis QChart::axisY(int id) const
             {
                 return m_presenter->axisY(id);
             }
             void QChart::removeAxisY(int id)
             {
                 m_presenter->removeAxisY(id);
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 -1

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
-            class BarGroup;
+            class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             // TODO: We don't need to have QChart tied to QGraphicsItem:
             //class QTCOMMERCIALCHART_EXPORT QChart
             //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
             // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific,
                     //ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QChartSeries* series);
                 //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
                 // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomInToRect(const QRectF& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void zoomReset();
                 void setDefaultAxisX(const QChartAxis& axis);
                 void setDefaultAxisY(const QChartAxis& axis);
                 QChartAxis defaultAxisX() const;
                 QChartAxis defaultAxisY() const;
                 QChartAxis axisY(int id) const;
                 int addAxisY(const QChartAxis& axis);
                 void removeAxisY(int id);
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsTextItem* m_titleItem;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/src.pro +15 -14

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
-            SOURCES += barchart/barchartseries.cpp \
+            SOURCES += \
-                barchart/bargroup.cpp \
                 barchart/bar.cpp \
-                barchart/stackedbarchartseries.cpp \
-                barchart/stackedbargroup.cpp \
-                barchart/percentbarchartseries.cpp \
-                barchart/percentbargroup.cpp \
                 barchart/barlabel.cpp \
                 barchart/barchartmodel.cpp \
                 barchart/separator.cpp \
-                barchart/bargroupbase.cpp \
                 barchart/qbarset.cpp \
                 barchart/qbarcategory.cpp \
+                barchart/qbarchartseries.cpp \
+                barchart/qpercentbarchartseries.cpp \
+                barchart/qstackedbarchartseries.cpp \
+                barchart/barpresenterbase.cpp \
+                barchart/barpresenter.cpp \
+                barchart/stackedbarpresenter.cpp \
+                barchart/percentbarpresenter.cpp \
                 linechart/linechartanimationitem.cpp \
                 linechart/linechartitem.cpp \
                 linechart/qlinechartseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 domain.cpp
             PRIVATE_HEADERS += linechart/linechartitem_p.h \
                 linechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
                 barchart/barchartmodel_p.h \
                 axisitem_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 chartdataset_p.h \
                 chartpresenter_p.h \
                 domain_p.h
             PUBLIC_HEADERS += linechart/qlinechartseries.h \
-                barchart/barchartseries.h \
+                barchart/qbarchartseries.h \
-                barchart/bargroup.h \
+                barchart/barpresenter.h \
-                barchart/stackedbarchartseries.h \
+                barchart/qstackedbarchartseries.h \
-                barchart/stackedbargroup.h \
+                barchart/stackedbarpresenter.h \
-                barchart/percentbarchartseries.h \
+                barchart/qpercentbarchartseries.h \
-                barchart/percentbargroup.h \
+                barchart/percentbarpresenter.h \
-                barchart/bargroupbase.h \
+                barchart/barpresenterbase.h \
                 barchart/qbarset.h \
                 barchart/qbarcategory.h \
                 qchartseries.h \
                 qchart.h \
                 qchartglobal.h \
                 qchartview.h \
                 qchartaxis.h
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

test/chartwidgettest/mainwidget.cpp +3 -3

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include <qlinechartseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
-            #include <barchartseries.h>
+            #include <qbarchartseries.h>
-            #include <stackedbarchartseries.h>
+            #include <qstackedbarchartseries.h>
-            #include <percentbarchartseries.h>
+            #include <qpercentbarchartseries.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 = new QBarSet;
                 QBarSet *set1 = new QBarSet;
                 QBarSet *set2 = new QBarSet;
                 QBarSet *set3 = new QBarSet;
                 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;
                     *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;
                 } else {
                     // TODO: check if data has a valid file name
                     Q_ASSERT(false);
                 }
                 // TODO: color of the series
                 QChartSeries *newSeries = 0;
                 if (series == "Scatter") {
                     QScatterSeries *scatter = new QScatterSeries();
                     for (int i(0); i < x.count() && i < y.count(); i++)
                         (*scatter) << QPointF(x.at(i), y.at(i));
                     m_chartWidget->addSeries(scatter);
                 } 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 = new QBarCategory;
                     *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 = new QBarCategory;
                     *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 = new QBarCategory;
                     *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)
             {
                 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::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