HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1586:9c6a61adadc9

renamed barseries files to abstractbarseries

sauimone -

r1586:9c6a61adadc9

parent child

Context file:

r1586:9c6a61adadc9

Expand all files

demos/chartthemes/themewidget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
-            #include <QBarSeries>
+            #include <QAbstractBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             #include <QCategoriesAxis>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(10),
                 m_valueCount(7),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
                 m_legendComboBox(createLegendBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(new QLabel("Legend:"));
                 settingsLayout->addWidget(m_legendComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
                 updateUI();
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
                         yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         QString label = "Slice " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox* ThemeWidget::createLegendBox() const
             {
                 QComboBox* legendComboBox = new QComboBox();
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 legendComboBox->addItem("Legend Left", Qt::AlignLeft);
                 legendComboBox->addItem("Legend Right", Qt::AlignRight);
                 return legendComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 QChart *chart = new QChart();
             //    chart->axisX()->setNiceNumbersEnabled(true);
             //    chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Area chart");
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 0;
                 QString name("Series ");
                 int nameIndex = 0;
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
                         if (lowerSeries){
                             const QList<QPointF>& points = lowerSeries->points();
                             upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
                         }else
                             upperSeries->append(QPointF(j, data.first.y()));
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(area);
                     chart->createDefaultAxes();
                     lowerSeries = upperSeries;
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 QChart* chart = new QChart();
                //TODO: chart->axisX()->setNiceNumbersEnabled(true);
                //TODO: chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Bar chart");
                 QStringList categories;
                 for (int i(0); i < valueCount; i++)
                     categories << QString::number(i);
                 QCategoriesAxis* axis = new QCategoriesAxis();
                 axis->append(categories);
                 QStackedBarSeries* series = new QStackedBarSeries(chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                         *set << data.first.y();
                     series->append(set);
                 }
                 chart->addSeries(series);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 QChart* chart = new QChart();
                 //TODO: chart->axisX()->setNiceNumbersEnabled(true);
                 //TODO: chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                     chart->createDefaultAxes();
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->append(data.second, data.first.y());
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setHorizontalPosition(hPos);
                     series->setVerticalPosition(0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                //TODO: chart->axisX()->setNiceNumbersEnabled(true);
                //TODO: chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                     chart->createDefaultAxes();
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 //TODO: chart->axisX()->setNiceNumbersEnabled(true);
                 //TODO: chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                     chart->createDefaultAxes();
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->hide();
                     }
                 } else {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignment(alignment);
                         chartView->chart()->legend()->show();
                     }
                 }
             }

src/barchart/barchart.pri +3 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/bar.cpp \
                 $$PWD/barchartitem.cpp \
                 $$PWD/percentbarchartitem.cpp \
                 $$PWD/groupedbarchartitem.cpp \
-                $$PWD/qbarseries.cpp \
+                $$PWD/qabstractbarseries.cpp \
                 $$PWD/qbarset.cpp \
                 $$PWD/qpercentbarseries.cpp \
                 $$PWD/qstackedbarseries.cpp \
                 $$PWD/qgroupedbarseries.cpp \
                 $$PWD/stackedbarchartitem.cpp \
                 $$PWD/qbarmodelmapper.cpp \
                 $$PWD/qvbarmodelmapper.cpp \
                 $$PWD/qhbarmodelmapper.cpp
             PRIVATE_HEADERS += \
                 $$PWD/bar_p.h \
                 $$PWD/barchartitem_p.h \
                 $$PWD/percentbarchartitem_p.h \
                 $$PWD/stackedbarchartitem_p.h \
                 $$PWD/groupedbarchartitem_p.h \
                 $$PWD/qbarset_p.h \
-                $$PWD/qbarseries_p.h \
+                $$PWD/qabstractbarseries_p.h \
                 $$PWD/qstackedbarseries_p.h\
                 $$PWD/qpercentbarseries_p.h \
                 $$PWD/qgroupedbarseries_p.h \
                 $$PWD/qbarmodelmapper_p.h
             PUBLIC_HEADERS += \
-                $$PWD/qbarseries.h \
+                $$PWD/qabstractbarseries.h \
                 $$PWD/qbarset.h \
                 $$PWD/qpercentbarseries.h \
                 $$PWD/qstackedbarseries.h \
                 $$PWD/qgroupedbarseries.h \
                 $$PWD/qbarmodelmapper.h \
                 $$PWD/qvbarmodelmapper.h \
                 $$PWD/qhbarmodelmapper.h

src/barchart/barchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                 }
             }
             //handlers
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void BarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem* label, m_labels) {
                     label->setVisible(visible);
                 }
                 update();
             }
             void BarChartItem::handleDataStructureChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 bool labelsVisible = m_series->isLabelsVisible();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set,c,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), m_series, SIGNAL(clicked(int, QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), m_series, SIGNAL(hovered(bool, QBarSet*)));
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), set, SIGNAL(hovered(bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                         // Labels
                         QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
                         label->setVisible(labelsVisible);
                         m_labels.append(label);
                     }
                 }
                 // TODO: Is this the right place to call it?
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 handleLayoutChanged();
             }
             void BarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 handleLabelsVisibleChanged(visible);
                 foreach(QGraphicsItem *item, childItems()) {
                     item->setVisible(visible);
                 }
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual QVector<QRectF> calculateLayout();
                 virtual void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items
                 void handleVisibleChanged();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
                 // Not owned.
                 QAbstractBarSeries *m_series;
                 QList<Bar *> m_bars;
                 QList<QGraphicsSimpleTextItem *> m_labels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/groupedbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "groupedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             GroupedBarChartItem::GroupedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> GroupedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = (scaleX / setCount) * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left();
                         xPos -= setCount*barWidth/2;
                         xPos += set*barWidth;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_groupedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "chartanimator_p.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * percentage * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set,category))) {
                             int p = m_series->d_func()->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             void PercentBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.cpp ~~src/barchart/qbarseries.cpp~~ renamed +18 -18

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
-                \class QBarSeries
+                \class QAbstractBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
-                QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
+                QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
-                \qmlclass BarSeries QBarSeries
+                \qmlclass BarSeries QAbstractBarSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
-                \property QBarSeries::barWidth
+                \property QAbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \qmlproperty real BarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
-                \property QBarSeries::count
+                \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int BarSeries::count
                 Holds the number of sets in series.
             */
             /*!
-                \property QBarSeries::labelsVisible
+                \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool BarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
-                \fn void QBarSeries::clicked(int index, QBarSet *barset)
+                \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal BarSeries::onClicked(int index, BarSet barset)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
-                \fn void QBarSeries::hovered(bool status, QBarSet* barset)
+                \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal BarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
-                \fn void QBarSeries::countChanged()
+                \fn void QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal BarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
-                \fn void QBarSeries::labelsVisibleChanged()
+                \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
-                \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
+                \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSeries::onAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
-                \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
+                \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSeries::onRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet BarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet BarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                     myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet BarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa BarSeries::append()
             */
             /*!
                 \qmlmethod bool BarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successfull, false otherwise.
             */
             /*!
                 \qmlmethod BarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
-                Constructs empty QBarSeries.
+                Constructs empty QAbstractBarSeries.
-                QBarSeries is QObject which is a child of a \a parent.
+                QAbstractBarSeries is QObject which is a child of a \a parent.
             */
             QAbstractBarSeries::QAbstractBarSeries(QObject *parent) :
                 QAbstractSeries(*new QAbstractBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
                 Q_D(QAbstractBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QAbstractBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QGroupedBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QAbstractBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all of the bar sets from the series
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAbstractBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createAxisX(QObject* parent)
             {
                 return new QCategoriesAxis(parent);
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createAxisY(QObject* parent)
             {
                 return new QValuesAxis(parent);
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QAbstractBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QAbstractBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
-            #include "moc_qbarseries.cpp"
+            #include "moc_qabstractbarseries.cpp"
-            #include "moc_qbarseries_p.cpp"
+            #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.h ~~src/barchart/qbarseries.h~~ renamed 0 0

NO CONTENT: file renamed from src/barchart/qbarseries.h to src/barchart/qabstractbarseries.h

src/barchart/qabstractbarseries_p.h ~~src/barchart/qbarseries_p.h~~ renamed +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
-            #ifndef QBARSERIES_P_H
+            #ifndef QABSTRACTBARSERIES_P_H
-            #define QBARSERIES_P_H
+            #define QABSTRACTBARSERIES_P_H
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
             class QAbstractBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QAbstractBarSeriesPrivate(QAbstractBarSeries *parent);
                 int categoryCount() const;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 QAbstractAxis* createAxisX(QObject* parent = 0);
                 QAbstractAxis* createAxisY(QObject* parent = 0);
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 QBarSet* barsetAt(int index);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
                 qreal minX();
                 qreal maxX();
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void updatedBars();
                 void restructuredBars();
                 void labelsVisibleChanged(bool visible);
             protected:
                 QList<QBarSet *> m_barSets;
                 qreal m_barWidth;
                 bool m_labelsVisible;
                 bool m_visible;
             private:
                 Q_DECLARE_PUBLIC(QAbstractBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif // QBARSERIESPRIVATE_P_H
+            #endif // QABSTRACTBARSERIES_P_H

src/barchart/qbarmodelmapper.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qbarset.h"
             #include "qchart.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QAbstractBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(barsetsAdded(QList<QBarSet*>)), d, SLOT(barSetsAdded(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(barsetsRemoved(QList<QBarSet*>)), d, SLOT(barSetsRemoved(QList<QBarSet*>)));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row of the model contains the \a first values of the QBarSets in the series.
                 The default value is 0.
             */
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             /*!
-                Returns the number of rows/columns of the model that are mapped as the data for QBarSeries
+                Returns the number of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             /*!
-                Sets the \a count of rows/columns of the model that are mapped as the data for QBarSeries
+                Sets the \a count of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = qMax(-1, firstBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = qMax(-1, lastBarSetSection);
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         //            if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                         return m_series->barSets().at(index.column() - m_firstBarSetSection);
                         //            else
                         //                return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSetSection || barSection > m_lastBarSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet* bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
                             QBarSet* bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
                                 bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->barSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for(int i = 0; i < sets.count(); i++)
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBarSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBarSetSection, sets.count());
                 for(int i = firstIndex + m_firstBarSetSection; i < firstIndex + m_firstBarSetSection + sets.count(); i++) {
                     m_model->setHeaderData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, sets.at(i - firstIndex - m_firstBarSetSection)->label());
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBarSetSection)->count(); j++)
                         m_model->setData(barModelIndex(i, j), sets.at(i - firstIndex - m_firstBarSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_barSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBarSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_barSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBarSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesAdded(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += count;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(index + m_first, count);
                 else
                     m_model->insertColumns(index + m_first, count);
                 for (int j = index; j < index + count; j++)
                     m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, j), m_barSets.at(barSetIndex)->at(j));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesRemoved(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= count;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(index + m_first, count);
                 else
                     m_model->removeColumns(index + m_first, count);
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setHeaderData(barSetIndex + m_firstBarSetSection, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, m_barSets.at(barSetIndex)->label());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, index), m_barSets.at(barSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_barSets.clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     // check if there is such model index
                     if (barIndex.isValid()) {
                         QBarSet *barSet = new QBarSet(m_model->headerData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical).toString());
                         while (barIndex.isValid()) {
                             barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             barIndex = barModelIndex(i, posInBar);
                         }
                         connect(barSet, SIGNAL(valuesAdded(int, int)), this, SLOT(valuesAdded(int, int)));
                         connect(barSet, SIGNAL(valuesRemoved(int, int)), this, SLOT(valuesRemoved(int, int)));
                         connect(barSet, SIGNAL(valueChanged(int)), this, SLOT(barValueChanged(int)));
                         connect(barSet, SIGNAL(labelChanged()), this, SLOT(barLabelChanged()));
                         m_series->append(barSet);
                         m_barSets.append(barSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief Building block for different bar charts
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
-                \sa QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries
+                \sa QAbstractBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSet QBarSet
                 BarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \sa BarSeries, GroupedBarSeries, StackedBarSeries, PercentBarSeries
             */
             /*!
                 \property QBarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \qmlproperty string BarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
                 Defines the font used by the barSet's label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
                 \property QBarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \property QBarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \property QBarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \fn void QBarSet::clicked(int index)
                 The signal is emitted if the user clicks with a mouse on top of barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 The signal is emitted if mouse is hovered on top of barset.
                 Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
             */
             /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the barSet has changed.
                 \sa label
             */
             /*!
                 \qmlsignal BarSet::onLabelChanged()
                 This signal is emitted when the label of the barSet has changed.
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onColorChanged(color color)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onBorderColorChanged(color color)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::labelColorChanged(QColor)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onLabelColorChanged(color color)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSet::onValuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSet::onValuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             /*!
                 \qmlsignal BarSet::onValueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
             */
             /*!
                 \qmlproperty int BarSet::count
                 The count of values on the barset
             */
             /*!
                 \qmlproperty QVariantList BarSet::values
                 The values of the barset. You can set either a list of reals or a list of points as values. If you set a list of
                 reals as values, the values are automatically completed to points by using the index of a value as it's
                 x-coordinate. For example:
                 \code
                     myBarSet1.values = [0, 5, 1, 5];
                     myBarSet2.values = [Qt.point(0, 1), Qt.point(1, 5), Qt.point(2.2, 4.3)];
                 \endcode
             */
             /*!
                 Constructs QBarSet with a label of \a label and with parent of \a parent
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(label,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF
                 d_ptr->append(QPointF(d_ptr->m_values.count(), value));
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are appended to end of barset
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> &values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convinience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
             //    append(value);
                 d_ptr->append(QPointF(d_ptr->m_values.count(), value));
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 \sa insert()
             */
             void QBarSet::remove(const int index, const int count)
             {
                 int removedCount = d_ptr->remove(index,count);
                 if (removedCount > 0) {
                     emit valuesRemoved(index,removedCount);
                 }
                 return;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 if (index >= 0 && index < d_ptr->m_values.count()) {
                     d_ptr->replace(index,value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count()) {
                     return 0;
                 }
                 return d_ptr->m_values.at(index).y();
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::operator [](const int index) const
             {
                 return at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     total += d_ptr->m_values.at(i).y();
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                       emit penChanged();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                   emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this barset
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Returns the color of the brush of barset.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this barset
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
                 Returns the color of pen of this barset
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
                 Sets the color of pen for this barset
             */
             void QBarSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             /*!
                 Returns the color of labels of this barset
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
                 Sets the color of labels for this barset
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelBrush(b);
                     emit labelColorChanged(color);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 m_values.append(value);
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(values.at(i));
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(QPointF(index,values.at(i)));
                     index++;
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             int QBarSetPrivate::remove(const int index, const int count)
             {
                 int removeCount = count;
                 if ((index <0) || (m_values.count() == 0)) {
                     // Invalid index or not values in list, remove nothing.
                     return 0;
                 } else if ((index + count) > m_values.count()) {
                     // Trying to remove more items than list has. Limit amount to be removed.
                     removeCount = m_values.count() - index;
                 }
                 int c = 0;
                 while (c < removeCount) {
                     m_values.removeAt(index);
                     c++;
                 }
                 emit restructuredBars();
                 return removeCount;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index,QPointF(index,value));
                 emit updatedBars();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index,value);
                 emit updatedBars();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush NOTIFY labelBrushChanged)
                 Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             public:
                 explicit QBarSet(const QString label, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setLabel(const QString label);
                 QString label() const;
                 void append(const qreal value);
                 void append(const QList<qreal> &values);
                 QBarSet& operator << (const qreal &value);
                 void insert(const int index, const qreal value);
                 void remove(const int index, const int count = 1);
                 void replace(const int index, const qreal value);
                 qreal at(const int index) const;
                 qreal operator [] (const int index) const;
                 int count() const;
                 qreal sum() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 QColor color();
                 void setColor(QColor color);
                 QColor borderColor();
                 void setBorderColor(QColor color);
                 QColor labelColor();
                 void setLabelColor(QColor color);
             Q_SIGNALS:
                 void clicked(int index);
                 void hovered(bool status);
                 void penChanged();
                 void brushChanged();
                 void labelChanged();
                 void labelBrushChanged();
                 void labelFontChanged();
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void labelColorChanged(QColor color);
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void valueChanged(int index);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)
-                friend class QBarSeries;
+                friend class QAbstractBarSeries;
                 friend class BarLegendMarker;
                 friend class BarChartItem;
                 friend class QAbstractBarSeriesPrivate;
                 friend class StackedBarChartItem;
                 friend class PercentBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/qgroupedbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qgroupedbarseries.h"
             #include "qgroupedbarseries_p.h"
             #include "groupedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QGroupedBarSeries
                 \brief Series for creating grouped bar chart
                 \mainclass
                 QGroupedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QGroupedBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {GroupedbarChart Example} {grouped bar chart example} to learn how to create a grouped bar chart.
                 \image examples_groupedbarchart.png
-                \sa QBarSet, QPercentBarSeries, QBarSeries, QStackedBarSeries
+                \sa QBarSet, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass GroupedBarSeries QGroupedBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QGroupedBarSeries.
                 QGroupedBarSeries is QObject which is a child of a \a parent.
             */
             QGroupedBarSeries::QGroupedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QGroupedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeGroupedBar.
             */
             QAbstractSeries::SeriesType QGroupedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeGroupedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(QGroupedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QGroupedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, -0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QGroupedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QGroupedBarSeries);
                 GroupedBarChartItem* bar = new GroupedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qgroupedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qgroupedbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef GROUPEDBARSERIES_H
             #define GROUPEDBARSERIES_H
             #include <QStringList>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QGroupedBarSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QGroupedBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QGroupedBarSeries)
                 Q_DISABLE_COPY(QGroupedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // GROUPEDBARSERIES_H

src/barchart/qgroupedbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QGROUPEDBARSERIES_P_H
             #define QGROUPEDBARSERIES_P_H
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QGroupedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QGroupedBarSeriesPrivate(QGroupedBarSeries* q);
                 Chart* createGraphics(ChartPresenter* presenter);
                 void scaleDomain(Domain& domain);
             private:
                 Q_DECLARE_PUBLIC(QGroupedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QGROUPEDBARSERIES_P_H

src/barchart/qhbarmodelmapper.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
                 \brief Horizontal model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
-                Horizontal model mapper is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
+                Horizontal model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass HBarModelMapper QHBarModelMapper
                 HBarModelMapper allows you to use your own QAbstractItemModel derived model with data in rows as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 HBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the model has
                 at least four rows). Each bar set would contain data starting from column 1. The name of a set would be defined by
                 the vertical header (of the row).
                 \code
                     BarSeries {
                         HBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetRow: 1
                             lastBarSetRow: 3
                             firstColumn: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QHBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty BarSeries HBarModelMapper::series
                 Defines the BarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QHBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel HBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. NOTE: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QHBarModelMapper::firstBarSetRow
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstBarSetRow
                 Defines which column of the model is used as the data source for the first bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::lastBarSetRow
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::lastBarSetRow
                 Defines which column of the model is used as the data source for the last bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::firstColumn
                 \brief Defines which column of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstColumn
                 Defines which column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QHBarModelMapper::columnCount
-                \brief Defines the number of columns of the model that are mapped as the data for QBarSeries
+                \brief Defines the number of columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of columns in the model)
             */
             /*!
                 \qmlproperty int HBarModelMapper::columnCount
-                Defines the number of columns of the model that are mapped as the data for QBarSeries. The default value is
+                Defines the number of columns of the model that are mapped as the data for QAbstractBarSeries. The default value is
                 -1 (count limited by the number of columns in the model)
             */
             /*!
                 \fn void QHBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstBarSetRowChanged()
                 Emitted when the firstBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::lastBarSetRowChanged()
                 Emitted when the lastBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstColumnChanged()
                 Emitted when the firstColumn has changed.
             */
             /*!
                 \fn void QHBarModelMapper::columnCountChanged()
                 Emitted when the columnCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             QAbstractItemModel* QHBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QHBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QAbstractBarSeries* QHBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
             void QHBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 if (firstBarSetRow != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
                     emit firstBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 if (lastBarSetRow != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetRow);
                     emit lastBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::firstColumn() const
             {
                 return QBarModelMapper::first();
             }
             void QHBarModelMapper::setFirstColumn(int firstColumn)
             {
                 if (firstColumn != first()) {
                     QBarModelMapper::setFirst(firstColumn);
                     emit firstColumnChanged();
                 }
             }
             int QHBarModelMapper::columnCount() const
             {
                 return QBarModelMapper::count();
             }
             void QHBarModelMapper::setColumnCount(int columnCount)
             {
                 if (columnCount != count()) {
                     QBarModelMapper::setCount(columnCount);
                     emit firstColumnChanged();
                 }
             }
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qpercentbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief Series for creating percent bar chart
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
-                \sa QBarSet, QStackedBarSeries, QBarSeries
+                \sa QBarSet, QStackedBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View9.qml 1
                 \beginfloatleft
                 \image demos_qmlchart9.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 minX = qMin(minX, -0.5);
                 maxX = qMax(maxX, x - 0.5);
                 minY = 0;
                 maxY = 100;
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem* bar = new PercentBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qpercentbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PERCENTBARSERIES_H
             #define PERCENTBARSERIES_H
             #include <QStringList>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPercentBarSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QPercentBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QPercentBarSeries)
                 Q_DISABLE_COPY(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qpercentbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QPERCENTBARSERIES_P_H
             #define QPERCENTBARSERIES_P_H
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QPercentBarSeriesPrivate(QPercentBarSeries* q);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
             private:
                 Q_DECLARE_PUBLIC(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qstackedbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
-                \sa QBarSet, QPercentBarSeries, QBarSeries
+                \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, -0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem* bar = new StackedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qstackedbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef STACKEDBARSERIES_H
             #define STACKEDBARSERIES_H
             #include <QStringList>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QStackedBarSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QStackedBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QStackedBarSeries)
                 Q_DISABLE_COPY(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARSERIES_H

src/barchart/qstackedbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QSTACKEDBARSERIES_P_H
             #define QSTACKEDBARSERIES_P_H
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QStackedBarSeriesPrivate(QStackedBarSeries* q);
                 Chart* createGraphics(ChartPresenter* presenter);
                 void scaleDomain(Domain& domain);
             private:
                 Q_DECLARE_PUBLIC(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qvbarmodelmapper.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \brief Vertical model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
-                Vertical model mapper is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
+                Vertical model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VBarModelMapper
                 \mainclass
                 VBarModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 VBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the
                 model has at least four columns). Each bar set would contain data starting from row 1. The name of a set would be
                 defined by the horizontal header (of the column).
                 \code
                     GroupedBarSeries {
                         VBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetColumn: 1
                             lastBarSetColumn: 3
                             firstRow: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QVBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty BarSeries VBarModelMapper::series
                 Defines the BarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. NOTE: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVBarModelMapper::firstBarSetColumn
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstBarSetColumn
                 Defines which column of the model is used as the data source for the first bar set. Default value
                 is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::lastBarSetColumn
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::lastBarSetColumn
                 Defines which column of the model is used as the data source for the last bar set. Default
                 value is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::firstRow
                 \brief Defines which row of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstRow
                 Defines which row of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QVBarModelMapper::rowCount
-                \brief Defines the number of rows of the model that are mapped as the data for QBarSeries
+                \brief Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VBarModelMapper::rowCount
-                Defines the number of rows of the model that are mapped as the data for QBarSeries. The default value is
+                Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstBarSetColumnChanged()
                 Emitted when the firstBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::lastBarSetColumnChanged()
                 Emitted when the lastBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVBarModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel* QVBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QVBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QAbstractBarSeries* QVBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
             void QVBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 if (firstBarSetColumn != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
                     emit firstBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 if (lastBarSetColumn != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
                     emit lastBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::firstRow() const
             {
                 return QBarModelMapper::first();
             }
             void QVBarModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     QBarModelMapper::setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVBarModelMapper::rowCount() const
             {
                 return QBarModelMapper::count();
             }
             void QVBarModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     QBarModelMapper::setCount(rowCount);
                     emit firstRowChanged();
                 }
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
-            #include "qbarseries_p.h"
+            #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + rangeY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             void StackedBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "qabstractseries_p.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *parent):QObject(parent),
                 m_domainIndex(0)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(domain) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::createDefaultAxes()
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     if(!m_seriesAxisXMap.value(i.key()))
                     {
                         QAbstractAxis* axisX = i.key()->d_ptr->createAxisX(this);
                         if(axisX) {
                             QObject::connect(axisX->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),i.value(),SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                             QObject::connect(i.value(),SIGNAL(rangeXChanged(qreal,qreal,int)),axisX->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                             axisX->d_ptr->m_orientation=Qt::Horizontal;
                             emit axisAdded(axisX,i.value());
                             m_seriesAxisXMap.insert(i.key(),axisX);
                         }
                     }
                     if(!m_seriesAxisYMap.value(i.key()))
                     {
                         QAbstractAxis* axisY = i.key()->d_ptr->createAxisY(this);
                         if(axisY) {
                             QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),i.value(),SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                             QObject::connect(i.value(),SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                             axisY->d_ptr->m_orientation=Qt::Vertical;
                             emit axisAdded(axisY,i.value());
                             m_seriesAxisYMap.insert(i.key(),axisY);
                         }
                     }
                 }
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.take(series);
                 if(!domain) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                 }
                 emit seriesRemoved(series);
                 delete domain;
                 domain = 0;
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
                 if(axisX) {
                     QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                     int x = axesX.indexOf(axisX);
                     if(x==-1) {
                         emit axisRemoved(axisX);
                         axisX->deleteLater();
                     }
                 }
                 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
                 if(axisY) {
                     QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                     int y = axesY.indexOf(axisY);
                     if(y==-1) {
                         emit axisRemoved(axisY);
                         axisY->deleteLater();
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
                 foreach(QAbstractSeries *s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesDomainMap.count()==0);
                 qDeleteAll(series);
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
             {
                 if(series == 0) return m_seriesAxisXMap.begin().value();
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_seriesAxisYMap.begin().value();
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxisX(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisXMap.take(series);
                 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                 if(oldAxis) {
                     int x = axesX.indexOf(oldAxis);
                     if(x==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int x = axesX.indexOf(axis);
                 if(x==-1) {
                     axis->d_ptr->m_orientation=Qt::Horizontal;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisXMap.insert(series,axis);
                 // Force range update
                 axis->d_ptr->updateRange();
             }
             void ChartDataSet::setAxisY(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisYMap.take(series);
                 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                 if(oldAxis) {
                     int y = axesY.indexOf(oldAxis);
                     if(y==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int y = axesY.indexOf(axis);
                 if(y==-1) {
                     axis->d_ptr->m_orientation=Qt::Vertical;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisYMap.insert(series,axis);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
                 return m_seriesDomainMap.value(series);
             }
             void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->move(dx,dy,size);
                 }
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisXMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qabstractaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qsplineseries.h"
             //items
             #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_labelBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_labelBrush);
                 chart->setDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (pen == legend->pen() || m_force)
                     legend->setPen(m_axisLinePen);
                 if (brush == legend->brush() || m_force)
                     legend->setBrush(m_chartBackgroundGradient);
                 if (font == legend->font() || m_force)
                     legend->setFont(m_labelFont);
                 if (brush == legend->labelBrush() || m_force)
                     legend->setLabelBrush(m_labelBrush);
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAbstractBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (d->m_data.m_slicePen.isThemed() || m_force)
                         d->setPen(penColor, true);
                     if (d->m_data.m_sliceBrush.isThemed() || m_force)
                         d->setBrush(brushColor, true);
                     if (d->m_data.m_labelBrush.isThemed() || m_force)
                         d->setLabelBrush(m_labelBrush.color(), true);
                     if (d->m_data.m_labelFont.isThemed() || m_force)
                         d->setLabelFont(m_labelFont, true);
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAbstractAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_labelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) :
                 QGraphicsObject(legend),
                 m_series(series),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
                 m_margin(2),
                 m_space(4)
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
                 m_textItem->setPen(pen);
             }
             QPen LegendMarker::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 QFontMetrics fn(font);
                 m_markerRect = QRectF(0,0,fn.height()/2,fn.height()/2);
                 updateGeometry();
             }
             QFont LegendMarker::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarker::setLabel(const QString label)
             {
                 m_textItem->setText(label);
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
             }
             QBrush LegendMarker::labelBrush() const
             {
                 return m_textItem->brush();
             }
             void LegendMarker::setGeometry(const QRectF& rect)
             {
                 const QRectF& textRect = m_textItem->boundingRect();
                 m_textItem->setPos(m_markerRect.width() + m_space + m_margin,rect.height()/2 - textRect.height()/2);
                 m_rectItem->setRect(m_markerRect);
                 m_rectItem->setPos(m_margin,rect.height()/2 - m_markerRect.height()/2);
                 prepareGeometryChange();
                 m_boundingRect = rect;
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(m_textItem->font());
                 QSizeF sh;
                   switch (which) {
                     case Qt::MinimumSize:
                         sh = QSizeF(fn.boundingRect("...").width(),fn.height());
                         break;
                     case Qt::PreferredSize:
                         sh = QSizeF(fn.boundingRect(m_textItem->text()).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     default:
                       break;
                   }
                   return sh;
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QAbstractBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendlayout_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
-            #include "qbarseries.h"
+            #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsLayout>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty color Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setFont(d_ptr->m_font);
                     }
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     updateGeometry();
                     if(isAttachedToChart()){
                         d_ptr->m_presenter->layout()->invalidate();
                     }else{
                         layout()->invalidate();
                     }
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
                 d_ptr->m_layout->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
                 d_ptr->m_layout->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 d_ptr->m_presenter->layout()->invalidate();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 d_ptr->m_presenter->layout()->invalidate();
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_layout(new LegendLayout(q)),
                 m_chart(chart),
                 m_items(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_labelBrush(QBrush()),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                m_layout->setOffset(x,y);
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                     m_items->addToGroup(marker);
                     m_markers<<marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
                 q_ptr->layout()->activate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 foreach (LegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         delete marker;
                         m_markers.removeAll(marker);
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 foreach (LegendMarker* marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(!marker->isVisible());
                     }
                 }
                 q_ptr->layout()->invalidate();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelColor(QColor color);
                 QColor labelColor() const;
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
             protected:
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void fontChanged(QFont font);
                 void labelColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
                 friend class LegendLayout;
                 friend class ChartLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/qabstractseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
-                \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QBarSeries, QStackedBarSeries,
+                \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmlclass AbstractSeries
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypeGroupedBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for QXYSeries.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for QXYSeries.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if(d_ptr->m_dataset) qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString& name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Sets the visibility of series to \a visible
             */
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             /*!
                 Returns the visibility of series
             */
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart* QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             void QAbstractSeries::adjustView()
             {
                 //TODO:
             }
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q):
                 q_ptr(q),
                 m_chart(0),
                 m_dataset(0),
                 m_visible(true)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/chartdataset/tst_chartdataset.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qabstractaxis.h>
             #include <qvaluesaxis.h>
             #include <qcategoriesaxis.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public Q_SLOTS:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private Q_SLOTS:
             	void chartdataset_data();
             	void chartdataset();
             	void addSeries_data();
             	void addSeries();
                 void setAxisX_data();
                 void setAxisX();
                 void setAxisY_data();
                 void setAxisY();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
                 void seriesCount_data();
             	void seriesCount();
                 void seriesIndex_data();
             	void seriesIndex();
             	void domain_data();
             	void domain();
                 void zoomInDomain_data();
             	void zoomInDomain();
             	/*
                 void zoomOutDomain_data();
                 void zoomOutDomain();
                 void scrollDomain_data();
                 void scrollDomain();
                 */
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
                 m_dataset = new ChartDataSet();
             }
             void tst_ChartDataSet::cleanup()
             {
                 QList<QAbstractSeries*> series = m_dataset->series();
                 foreach(QAbstractSeries* serie, series)
                 {
                     m_dataset->removeSeries(serie);
                 }
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axisX(0) == 0);
             	QVERIFY(m_dataset->axisY(0) == 0);
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(m_dataset->seriesIndex(series),-1);
             	QVERIFY(m_dataset->domain(series) == 0);
             	QVERIFY(m_dataset->axisX(series) == 0);
             	QVERIFY(m_dataset->axisY(series) == 0);
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QAbstractBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
             	QTest::newRow("line") << line;
             	QTest::newRow("area") << area;
             	QTest::newRow("scatter") << scatter;
             	QTest::newRow("spline") << spline;
             	QTest::newRow("pie") << pie;
                 QTest::newRow("bar") << bar;
             	QTest::newRow("percent") << percent;
             	QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 if(series->type()==QAbstractSeries::SeriesTypePie){
                     TRY_COMPARE(spy0.count(), 0);
                 }else{
                     TRY_COMPARE(spy0.count(), 2);
                 }
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::setAxisX_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QAbstractBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
                 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
                 QList<QAbstractAxis*> axes0;
                 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
                 axes0 << axes0.last();
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << axes0 << 2;
                 //TODO: add more test cases
             }
             void tst_ChartDataSet::setAxisX()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::setAxisY_data()
             {
                 setAxisX_data();
             }
             void tst_ChartDataSet::setAxisY()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeSeries(series);
                 TRY_COMPARE(spy0.count(), 0);
                 if (series->type() == QAbstractSeries::SeriesTypePie) {
                     TRY_COMPARE(spy1.count(), 0);
                 }
                 else {
                     TRY_COMPARE(spy1.count(), 2);
                 }
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
                         << new QScatterSeries(this))
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
                         << new QValuesAxis(this)) << 3;
                 //TODO:
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeAllSeries();
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), axisCount);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), seriesList.count());
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<int>("seriesCount");
                 QTest::newRow("line,line, line, spline  3") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) ) << 3;
                 QTest::newRow("scatter,scatter, line, line  2") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(int, seriesCount);
                 foreach(QAbstractSeries* series, seriesList){
                       m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
                 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->removeSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 1)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(2));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->removeSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2 && i != 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(2));
                 m_dataset->addSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i == 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
                     else if (i == 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 QVERIFY(m_dataset->domain(series));
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 QList<QVariant> arguments = spy2.takeFirst();
                 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
                 QVERIFY(m_dataset->domain(series) == domain);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 /*
                 QValuesAxis* axis = new QValuesAxis();
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxisX(seriesList.at(i), axis);
                 }
             */
                 m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 }
                 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll(spyList);
             }
             /*
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 m_dataset->addSeries(series0, axis0);
                 m_dataset->addSeries(series1, axis1);
                 m_dataset->addSeries(series2, axis2);
                 Domain* domain0 = m_dataset->domain(series0);
                 Domain* domain1 = m_dataset->domain(series1);
                 Domain* domain2 = m_dataset->domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 m_dataset->zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 m_dataset->addSeries(series0, axis0);
                 m_dataset->addSeries(series1, axis1);
                 m_dataset->addSeries(series2, axis2);
                 Domain* domain0 = m_dataset->domain(series0);
                 Domain* domain1 = m_dataset->domain(series1);
                 Domain* domain2 = m_dataset->domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 m_dataset->scrollDomain(10,10,QSize(1000,1000));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             */
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

tests/auto/qbarseries/tst_qbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarseries_data();
                 void qbarseries();
                 void type_data();
                 void type();
                 void append_data();
                 void append();
                 void remove_data();
                 void remove();
                 void appendList_data();
                 void appendList();
                 void count_data();
                 void count();
                 void barSets_data();
                 void barSets();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void clearWithAnimations();
             private:
                 QAbstractBarSeries* m_barseries;
                 QAbstractBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
             };
             void tst_QBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
             }
             void tst_QBarSeries::init()
             {
                 m_barseries = new QAbstractBarSeries();
                 m_barseries_with_sets = new QAbstractBarSeries();
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
                     m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::cleanup()
             {
                 foreach(QBarSet* s, m_testSets) {
                     m_barseries_with_sets->remove(s);
                     delete s;
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
             }
             void tst_QBarSeries::qbarseries_data()
             {
             }
             void tst_QBarSeries::qbarseries()
             {
                 QAbstractBarSeries *barseries = new QAbstractBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QBarSeries::type_data()
             {
             }
             void tst_QBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
             void tst_QBarSeries::append_data()
             {
             }
             void tst_QBarSeries::append()
             {
                 QVERIFY(m_barseries->count() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
                 ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding same set again
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding null set
                 ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
             }
             void tst_QBarSeries::remove_data()
             {
             }
             void tst_QBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
                 ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
                 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // remove some sets
                 ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
                     ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 0);
             }
             void tst_QBarSeries::appendList_data()
             {
             }
             void tst_QBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->count() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Append same sets again (should fail, count should remain same)
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
                 ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
             }
             void tst_QBarSeries::count_data()
             {
             }
             void tst_QBarSeries::count()
             {
                 QVERIFY(m_barseries->count() == 0);
                 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
             }
             void tst_QBarSeries::barSets_data()
             {
             }
             void tst_QBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
                 QVERIFY(m_barseries->isLabelsVisible() == false);
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
             }
             void tst_QBarSeries::mouseclicked_data()
             {
             }
             void tst_QBarSeries::mouseclicked()
             {
                 QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(102,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(186,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(271,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(127,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(212,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(296,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QBarSeries::mousehovered_data()
             {
             }
             void tst_QBarSeries::mousehovered()
             {
                 QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(102,142));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(127,142));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(127,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
             }
             void tst_QBarSeries::clearWithAnimations()
             {
                 QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
                 view.chart()->addSeries(series);
                 view.show();
                 series->clear();
             }
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

tests/auto/qchart/tst_qchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qvaluesaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValuesAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void margins_data();
                 void margins();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scroll_data();
                 void scroll();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::createTestData()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                 m_chart->addSeries(series0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(m_chart->axisX());
                 QVERIFY(m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scroll(0,0);
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::addColumn<QAbstractAxis *>("axis");
                 QAbstractSeries* series0 = new QLineSeries(this);
                 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
                 QAbstractSeries* series2 = new QScatterSeries(this);
                 QAbstractSeries* series3 = new QSplineSeries(this);
                 QAbstractSeries* series4 = new QPieSeries(this);
                 QAbstractSeries* series5 = new QAbstractBarSeries(this);
                 QAbstractSeries* series6 = new QPercentBarSeries(this);
                 QAbstractSeries* series7 = new QStackedBarSeries(this);
                 QValuesAxis* axis = new QValuesAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QAbstractAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
                 QTest::newRow("default axis: areaSeries") << series1 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
                 QTest::newRow("default axis: scatterSeries") << series2 << (QAbstractAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
                 QTest::newRow("default axis: splineSeries") << series3 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
                 QTest::newRow("default axis: pieSeries") << series4 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
                 QTest::newRow("default axis: barSeries") << series5 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
                 QTest::newRow("default axis: percentBarSeries") << series6 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
                 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAbstractAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->series().count(), 1);
                 QCOMPARE(m_chart->series().first(), series);
                 QVERIFY(series->chart() == m_chart);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
             }
             void tst_QChart::axisX()
             {
                 QVERIFY(m_chart->axisX());
                 QAbstractAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis0");
                 QTest::addColumn<QAbstractAxis*>("axis1");
                 QTest::addColumn<QAbstractAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QAbstractAxis*)0 << new QValuesAxis() << new QValuesAxis();
                 QTest::newRow("3 optional") << new QValuesAxis() << new QValuesAxis() << new QValuesAxis();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis0);
                 QFETCH(QAbstractAxis*, axis1);
                 QFETCH(QAbstractAxis*, axis2);
                 QAbstractAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0);
                 m_chart->setAxisY(axis0,series0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1);
                 m_chart->setAxisY(axis1,series1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2);
                 m_chart->setAxisY(axis2,series2);
                 if (!axis0)
                     axis0 = defaultAxisY;
                 if (!axis1)
                     axis1 = defaultAxisY;
                 if (!axis2)
                     axis2 = defaultAxisY;
                 QVERIFY(m_chart->axisY(series0) == axis0);
                 QVERIFY(m_chart->axisY(series1) == axis1);
                 QVERIFY(m_chart->axisY(series2) == axis2);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
                 QCOMPARE(deleteSpy1.count(), 1);
                 QCOMPARE(deleteSpy2.count(), 1);
                 QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAbstractAxis *, axis);
                 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
                 QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scroll_data()
             {
             }
             void tst_QChart::scroll()
             {
                 qFatal("implement me");
                 createTestData();
                 //TODO qreal min = m_chart->axisY()->min();
                 m_chart->scroll(0,0);
                 //TODO QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 qFatal("implement me");
                 /*
                 QFETCH(QRectF, rect);
                 createTestData();
                 QRectF marigns = m_chart->margins();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<m_chart->axisX()->min());
                     QVERIFY(maxX>m_chart->axisX()->max());
                     QVERIFY(minY<m_chart->axisY()->min());
                     QVERIFY(maxY>m_chart->axisY()->max());
                 }
                 */
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 qFatal("implement me");
                 createTestData();
                 /*
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < m_chart->axisX()->min());
                 QVERIFY(maxX > m_chart->axisX()->max());
                 QVERIFY(minY < m_chart->axisY()->min());
                 QVERIFY(maxY > m_chart->axisY()->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(m_chart->axisX()->min()));
                 else
                     QCOMPARE(minX, m_chart->axisX()->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(m_chart->axisY()->min()));
                 else
                     QCOMPARE(minY, m_chart->axisY()->min());
                 QVERIFY(maxX == m_chart->axisX()->max());
                 QVERIFY(maxY == m_chart->axisY()->max());
                 */
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

tests/chartwidgettest/mainwidget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartview.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qlineseries.h"
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
-            #include <qbarseries.h>
+            #include <qabstractbarseries.h>
             #include <qgroupedbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // 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);
                 initCheckboxes(grid);
                 // 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);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
                             this, SLOT(addSeries(QString,int,int,QString,bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(labels.at(i), column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Grouped bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
                     QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QAbstractBarSeries(this);
                         QCategoriesAxis* axis = new QCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Grouped bar") {
                         series = new QGroupedBarSeries(this);
                         QCategoriesAxis* axis = new QCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
                         QCategoriesAxis* axis = new QCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else {
                         series = new QPercentBarSeries(this);
                         QCategoriesAxis* axis = new QCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     }
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
                         series->append(set);
                     }
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
                 m_chart->createDefaultAxes();
             }
             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_chart->setTheme((QChart::ChartTheme) themeIndex);
             }

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