HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1587:60ca912b003e

made qabstractbarseries constructor protected. Updated tests

sauimone -

r1587:60ca912b003e

parent child

Context file:

r1587:60ca912b003e

Collapse all files

plugins/declarative/declarativechart.cpp 0 -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 "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             #include "qcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animation
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty string ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Axis ChartView::axisX
               The x-axis of the chart.
             */
             /*!
               \qmlproperty Axis ChartView::axisY
               The default y-axis of the chart.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               The space between the top of chart view and the top of the plot area. The title (if non-empty) is drawn on top margin
               area of the chart view. Top margin area is also used by legend, if aligned to top.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               The space between the bottom of chart view and the bottom of the plot area. The bottom margin area may be used by
               legend (if aligned to bottom), x-axis, x-axis labels and x-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               The space between the left side of chart view and the left side of the plot area. The left margin area may be used by
               legend (if aligned to left), y-axis, y-axis labels and y-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               The space between the right side of chart view and the right side of the plot area. The right margin area may be used
               by legend (if aligned to right).
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name)
               Creates a series object of \a type to the chart. For example:
               \code
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series");
                 scatter.markerSize = 22;
                 scatter.append(1.1, 2.0);
               \endcode
             */
             /*!
               \qmlmethod Axis ChartView::axisY(QAbstractSeries *series)
               The y-axis of the series. This is the same as the default y-axis of the chart as multiple y-axes are not yet supported.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlsignal ChartView::onTopMarginChanged(real margin)
               The top margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onBottomMarginChanged(real margin)
               The bottom margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onLeftMarginChanged(real margin)
               The left margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onRightMarginChanged(real margin)
               The right margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
                 m_chartMargins = m_chart->margins();
                 connect(m_chart, SIGNAL(marginsChanged(QRectF)), this, SLOT(handleMarginsChanged(QRectF)));
             }
             void DeclarativeChart::handleMarginsChanged(QRectF newMargins)
             {
                 if (m_chartMargins.top() != newMargins.top())
                     topMarginChanged(m_chart->margins().top());
                 if (m_chartMargins.bottom() != newMargins.bottom())
                     bottomMarginChanged(m_chart->margins().bottom());
                 if (m_chartMargins.left() != newMargins.left())
                     leftMarginChanged(m_chart->margins().left());
                 if (m_chartMargins.right() != newMargins.right())
                     rightMarginChanged(m_chart->margins().right());
                 m_chartMargins = m_chart->margins();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         // TODO: how about optional y-axis?
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }
                 }
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 return m_chart->axisX(series);
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont& font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::topMargin()
             {
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 return m_chart->margins().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
-                case DeclarativeChart::SeriesTypeBar:
-                    series = new DeclarativeBarSeries();
-                    break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypeGroupedBar:
                     series = new DeclarativeGroupedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/plugin.cpp 0 -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 <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include <QVXYModelMapper>
             #include <QHXYModelMapper>
             #include <QHPieModelMapper>
             #include <QVPieModelMapper>
             #include <QHBarModelMapper>
             #include <QVBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
-                    qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeGroupedBarSeries>(uri, 1, 0, "GroupedBarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValuesAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QCategoriesAxis>(uri, 1, 0, "CategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                       QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                       QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QScatterSeries>(uri, 1, 0, "QScatterSeries",
                                                       QLatin1String("Trying to create uncreatable: QScatterSeries."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                       QLatin1String("Trying to create uncreatable: QPieSeries."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "QBarSet",
                                                       QLatin1String("Trying to create uncreatable: QBarSet."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                       QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                       QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                       QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                       QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                       QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                       QLatin1String("Trying to create uncreatable: AbstractAxis."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: XYModelMapper."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))

src/barchart/qabstractbarseries.cpp 0 -8

             /****************************************************************************
             **
             ** 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 "qabstractbarseries.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 QAbstractBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 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 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 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 QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int BarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \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 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 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 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 QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \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 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 QAbstractBarSeries.
                 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_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.h +4 -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$
             **
             ****************************************************************************/
             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QAbstractBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QAbstractBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
-            public:
+            protected:
                 explicit QAbstractBarSeries(QObject *parent = 0);
+            public:
                 virtual ~QAbstractBarSeries();
-                QAbstractSeries::SeriesType type() const;
+                virtual QAbstractSeries::SeriesType type() const = 0;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
                 QList<QBarSet*> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 bool isLabelsVisible() const;
             protected:
                 explicit QAbstractBarSeries(QAbstractBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void hovered(bool status, QBarSet *barset);
                 void countChanged();
                 void labelsVisibleChanged();
                 void barsetsAdded(QList<QBarSet*> sets);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
                 Q_DECLARE_PRIVATE(QAbstractBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

tests/auto/chartdataset/tst_chartdataset.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 <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 <qabstractbarseries.h>
+            #include <qgroupedbarseries.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* bar = new QGroupedBarSeries(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* bar = new QGroupedBarSeries(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 +9 -15

             /****************************************************************************
             **
             ** 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 <qabstractbarseries.h>
+            #include <qgroupedbarseries.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;
+                QGroupedBarSeries* m_barseries;
-                QAbstractBarSeries* m_barseries_with_sets;
+                QGroupedBarSeries* 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 = new QGroupedBarSeries();
-                m_barseries_with_sets = new QAbstractBarSeries();
+                m_barseries_with_sets = new QGroupedBarSeries();
                 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();
+                QGroupedBarSeries *barseries = new QGroupedBarSeries();
                 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();
+                QGroupedBarSeries* series = new QGroupedBarSeries();
                 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();
+                QGroupedBarSeries* series = new QGroupedBarSeries();
                 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();
+                QGroupedBarSeries* series = new QGroupedBarSeries();
                 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 +2 -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 <qabstractbarseries.h>
+            #include <qgroupedbarseries.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* series5 = new QGroupedBarSeries(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/dataseriedialog.cpp 0 -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 "dataseriedialog.h"
             #include <QDialogButtonBox>
             #include <QGridLayout>
             #include <QCheckBox>
             #include <QPushButton>
             #include <QGroupBox>
             #include <QRadioButton>
             #include <QLabel>
             #include <QDebug>
             DataSerieDialog::DataSerieDialog(QWidget *parent) :
                 QDialog(parent)
             {
                 QDialogButtonBox *addSeriesBox = new QDialogButtonBox(Qt::Horizontal);
                 QPushButton *b = addSeriesBox->addButton(QDialogButtonBox::Ok);
                 connect(b, SIGNAL(clicked()), this, SLOT(accept()));
                 b = addSeriesBox->addButton(QDialogButtonBox::Cancel);
                 connect(b, SIGNAL(clicked()), this, SLOT(reject()));
                 QGridLayout *grid = new QGridLayout();
                 m_seriesTypeSelector = seriesTypeSelector();
                 m_columnCountSelector = columnCountSelector();
                 m_rowCountSelector = rowCountSelector();
                 m_dataCharacteristicsSelector = dataCharacteristicsSelector();
                 grid->addWidget(m_seriesTypeSelector, 0, 0);
                 grid->addWidget(m_columnCountSelector, 0, 1);
                 grid->addWidget(m_rowCountSelector, 1, 1);
                 grid->addWidget(m_dataCharacteristicsSelector, 1, 0);
                 m_labelsSelector = new QCheckBox("Labels defined");
                 m_labelsSelector->setChecked(true);
                 grid->addWidget(m_labelsSelector, 2, 0);
                 grid->addWidget(addSeriesBox, 3, 1);
                 setLayout(grid);
             }
             QGroupBox *DataSerieDialog::seriesTypeSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *line = new QRadioButton("Line");
                 line->setChecked(true);
                 layout->addWidget(line);
                 layout->addWidget(new QRadioButton("Area"));
                 layout->addWidget(new QRadioButton("Pie"));
-                layout->addWidget(new QRadioButton("Bar"));
                 layout->addWidget(new QRadioButton("Grouped bar"));
                 layout->addWidget(new QRadioButton("Stacked bar"));
                 layout->addWidget(new QRadioButton("Percent bar"));
                 layout->addWidget(new QRadioButton("Scatter"));
                 layout->addWidget(new QRadioButton("Spline"));
                 QGroupBox *groupBox = new QGroupBox("Series type");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::columnCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *radio = new QRadioButton("1");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("2"));
                 layout->addWidget(new QRadioButton("3"));
                 layout->addWidget(new QRadioButton("4"));
                 layout->addWidget(new QRadioButton("5"));
                 layout->addWidget(new QRadioButton("8"));
                 layout->addWidget(new QRadioButton("10"));
                 layout->addWidget(new QRadioButton("100"));
                 QGroupBox *groupBox = new QGroupBox("Column count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::rowCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("1"));
                 QRadioButton *radio = new QRadioButton("10");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("50"));
                 layout->addWidget(new QRadioButton("100"));
                 layout->addWidget(new QRadioButton("1000"));
                 layout->addWidget(new QRadioButton("10000"));
                 layout->addWidget(new QRadioButton("100000"));
                 layout->addWidget(new QRadioButton("1000000"));
                 QGroupBox *groupBox = new QGroupBox("Row count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::dataCharacteristicsSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("Linear"));
                 layout->addWidget(new QRadioButton("Constant"));
                 layout->addWidget(new QRadioButton("Random"));
                 layout->addWidget(new QRadioButton("Sin"));
                 layout->addWidget(new QRadioButton("Sin + random"));
                 QGroupBox *groupBox = new QGroupBox("Data Characteristics");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             void DataSerieDialog::accept()
             {
                 accepted(radioSelection(m_seriesTypeSelector),
                          radioSelection(m_columnCountSelector).toInt(),
                          radioSelection(m_rowCountSelector).toInt(),
                          radioSelection(m_dataCharacteristicsSelector),
                          m_labelsSelector->isChecked());
                 QDialog::accept();
             }
             void DataSerieDialog::selectRadio(QGroupBox *groupBox, int defaultSelection)
             {
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 Q_ASSERT(layout->count());
                 QLayoutItem *item = 0;
                 if (defaultSelection == -1) {
                     item = layout->itemAt(0);
                 } else if (layout->count() > defaultSelection) {
                     item = layout->itemAt(defaultSelection);
                 }
                 Q_ASSERT(item);
                 QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                 Q_ASSERT(radio);
                 radio->setChecked(true);
             }
             QString DataSerieDialog::radioSelection(QGroupBox *groupBox)
             {
                 QString selection;
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 for (int i(0); i < layout->count(); i++) {
                     QLayoutItem *item = layout->itemAt(i);
                     Q_ASSERT(item);
                     QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                     Q_ASSERT(radio);
                     if (radio->isChecked()) {
                         selection = radio->text();
                         break;
                     }
                 }
                 qDebug() << "radioSelection: " << selection;
                 return selection;
             }

tests/chartwidgettest/mainwidget.cpp +2 -9

             /****************************************************************************
             **
             ** 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 <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"
+                } else if (seriesName == "Grouped 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") {
+                    if (seriesName == "Grouped 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