HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1429:39a4e8ac4330

changed barset name to label to be consistent with pie series. Series have names, barsets and pieslices have labels

sauimone -

r1429:39a4e8ac4330

parent child

Context file:

r1429:39a4e8ac4330

Collapse all files

src/barchart/qbarmodelmapper.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "qchart.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 The instance of this class cannot be created directly. QHBarModelMapper of QVBarModelMapper should be used instead. This class is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
                 Curently it is NOT possible to use both QAbstractItemModel and QBarSeries model API.
                 When the series is set to the mapper the QBarSeries and QBarSet API that affect the data (append, setValue, remove) should not be used.
                 The model and the QBarSeries won't be kept in sync. Model API should be used to insert,remove,modify BarSets.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \property QBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \property QBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \property QBarModelMapper::first
                 \brief Defines which item of the model's row/column should be mapped as the value of the first QBarSet in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \property QBarModelMapper::count
                 \brief Defines the number of rows/columns of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 // TODO: TO be implemented
             }
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = qMax(-1, firstBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = qMax(-1, lastBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Resets the QBarModelMapper to the default state.
                 first: 0; count: -1; firstBarSetSection: -1; lastBarSetSection: -1; categoriesSection: -1
             */
             void QBarModelMapper::reset()
             {
                 Q_D(QBarModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_firstBarSetSection = -1;
                 d->m_lastBarSetSection = -1;
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         //            if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                         return m_series->barSets().at(index.column() - m_firstBarSetSection);
                         //            else
                         //                return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSetSection || barSection > m_lastBarSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet* bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
                             QBarSet* bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
-                                bar->setName(m_model->headerData(section, orientation).toString());
+                                bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     // check if there is such model index
                     if (barIndex.isValid()) {
                         QBarSet *barSet = new QBarSet(m_model->headerData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical).toString());
                         while (barIndex.isValid()) {
                             barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             barIndex = barModelIndex(i, posInBar);
                         }
                         m_series->append(barSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +6 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries 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
             */
             /*!
                 \property QBarSeries::barWidth
                 \brief 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 QGroupedBarSeries this value means the width of one group of bars instead of just one bar. This is
                 because with grouped series it is more logical to set width of whole group and let the chart calculate correct
                 width for bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \property QBarSeries::count
                 \brief Holds the number of sets in series.
             */
             /*!
                 \property QBarSeries::labelsVisible
                 \brief Defines the visibility of the labels in series
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, int index)
                 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
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QBarSeries::labelsVisibleChanged()
                  This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::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 QGroupedBarSeries this value means the width of one group of bars instead of just one bar. This is
                 because with grouped series it is more logical to set widht of whole group and let the chart calculate correct
                 width for bar.
                 \sa QGroupedBarSeries
             */
             void QBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QBarSeries);
                 d->setBarWidth(width);
+                emit barWidthChanged();
             }
             /*!
                 Returns the width of bars.
             */
             qreal QBarSeries::barWidth() const
             {
                 Q_D(const QBarSeries);
                 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 QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
+                    emit barsetCountChanged();
                 }
                 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 QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
+                    emit barsetCountChanged();
                 }
                 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 QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
+                    emit barsetCountChanged();
                 }
                 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 QBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
+                    emit barsetCountChanged();
                 }
                 return success;
             }
             /*!
                 Removes all of the bar sets from the series
             */
             void QBarSeries::clear()
             {
                 Q_D(QBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
+                    emit barsetCountChanged();
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             void QBarSeriesPrivate::setCategories(QStringList categories)
             {
                 m_categories = categories;
             }
             void QBarSeriesPrivate::insertCategory(int index, const QString category)
             {
                 m_categories.insert(index, category);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::removeCategory(int index)
             {
                 m_categories.removeAt(index);
                 emit categoriesUpdated();
             }
             int QBarSeriesPrivate::categoryCount() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories.count();
                 }
                 // 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;
             }
             QStringList QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
                 QStringList categories;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     categories.append(QString::number(i));
                 }
                 return categories;
             }
             void QBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 if ((category >= 0) && (category < m_categories.count())) {
                     return m_categories.at(category);
                 }
                 return QString::number(category);
             }
             qreal QBarSeriesPrivate::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).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::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).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::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).y();
             }
             qreal QBarSeriesPrivate::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).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::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).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::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).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::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 QBarSeriesPrivate::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)->at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::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)->at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QBarSeriesPrivate::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* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 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*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 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()));
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 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()));
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 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()));
                 }
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 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()));
                 }
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 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()));
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

src/barchart/qbarset.cpp +17 -23

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
-                \property QBarSet::name
+                \property QBarSet::label
-                \brief Defines the name of the barSet.
+                \brief Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
-                \fn void QBarSet::nameChanged()
+                \fn void QBarSet::labelChanged()
-                This signal is emitted when the name of the barSet has changed.
+                This signal is emitted when the label of the barSet has changed.
-                \sa name
+                \sa label
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
-                \fn void QBarSet::labelChanged()
-                This signal is emitted when the label of the barSet has changed.
-            */
-            /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
                 \sa append(), insert()
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             void valueChanged(int index);
             /*!
-                Constructs QBarSet with a name of \a name and with parent of \a parent
+                Constructs QBarSet with a label of \a label and with parent of \a parent
             */
-            QBarSet::QBarSet(const QString name, QObject *parent)
+            QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent)
-                ,d_ptr(new QBarSetPrivate(name,this))
+                ,d_ptr(new QBarSetPrivate(label,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
-                Sets new \a name for set.
+                Sets new \a label for set.
             */
-            void QBarSet::setName(const QString name)
+            void QBarSet::setLabel(const QString label)
             {
-                d_ptr->m_name = name;
+                d_ptr->m_label = label;
-                emit nameChanged();
+                emit labelChanged();
             }
             /*!
-                Returns name of the set.
+                Returns label of the set.
             */
-            QString QBarSet::name() const
+            QString QBarSet::label() const
             {
-                return d_ptr->m_name;
+                return d_ptr->m_label;
             }
             /*!
                 Appends a point to set. Parameter \a value x coordinate defines the
                 position in x-axis and y coordinate defines the height of bar.
                 Depending on presentation (QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries)
                 the x values are used or ignored.
             */
             void QBarSet::append(const QPointF value)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of \a values to set. Works like append with single point.
                 \sa append()
             */
             void QBarSet::append(const QList<QPointF> values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Appends new value \a value to the end of set. Internally the value is converted to QPointF,
                 with x coordinate being the index of appended value and y coordinate is the value.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF and use other append(QPointF) method.
                 append(QPointF(d_ptr->m_values.count(), value));
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are converted to QPointF, where x coordinate is the index of point and y coordinate is the value.
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convinience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Convinience operator. Same as append, with QPointF \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const QPointF &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const QPointF value)
             {
                 d_ptr->insert(index,value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 Returns true if remove operation was succesfull.
                 \sa insert()
             */
             bool QBarSet::remove(const int index, const int count)
             {
                 bool success = d_ptr->remove(index,count);
                 if (success) {
                     emit valuesRemoved(index,count);
                 }
                 return success;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 d_ptr->replace(index,value);
                 emit valueChanged(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const QPointF value)
             {
                 d_ptr->replace(index,value);
                 emit valueChanged(index);
             }
             /*!
                 Returns value of set indexed by \a index. Note that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
                 If the index is out of bounds QPointF(0, 0.0) is returned.
             */
             QPointF QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count()) {
                     return QPointF(index, 0.0);
                 }
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns value of set indexed by \a index. ote that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
             */
             QPointF QBarSet::operator [](const int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset. The sum is sum of y coordinates in the QPointF representation.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     //total += d_ptr->m_values.at(i);
                     total += d_ptr->m_values.at(i).y();
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                       emit penChanged();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                   emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarSetPrivate::QBarSetPrivate(const QString name, QBarSet *parent) : QObject(parent),
+            QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
-                m_name(name)
+                m_label(label)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 m_values.append(value);
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(values.at(i));
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(QPointF(index,values.at(i)));
                     index++;
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             bool QBarSetPrivate::remove(const int index, const int count)
             {
                 if ((index + count) > m_values.count()) {
                     // cant remove more values than there are
                     return false;
                 }
                 int c = count;
                 while (c > 0) {
                     m_values.removeAt(index);
                     c--;
                 }
                 emit restructuredBars();
                 return true;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index,QPointF(index,value));
                 emit updatedBars();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index,value);
                 emit updatedBars();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +8 -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$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
-                Q_PROPERTY(QString name READ name WRITE setName)
+                Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
-                Q_PROPERTY(QPen pen READ pen WRITE setPen)
+                Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
-                Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
+                Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
-                Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush)
+                Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush NOTIFY labelBrushChanged)
-                Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont)
+                Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
             public:
-                explicit QBarSet(const QString name, QObject *parent = 0);
+                explicit QBarSet(const QString label, QObject *parent = 0);
                 virtual ~QBarSet();
-                void setName(const QString name);
+                void setLabel(const QString label);
-                QString name() const;
+                QString label() const;
                 void append(const QPointF value);
                 void append(const QList<QPointF> values);
                 void append(const qreal value);
                 void append(const QList<qreal> values);
                 QBarSet& operator << (const qreal &value);
                 QBarSet& operator << (const QPointF &value);
                 void insert(const int index, const qreal value);
                 void insert(const int index, const QPointF value);
                 bool remove(const int index, const int count = 1);
                 void replace(const int index, const qreal value);
                 void replace(const int index, const QPointF value);
                 QPointF at(const int index) const;
                 QPointF operator [] (const int index) const;
                 int count() const;
                 qreal sum() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
             Q_SIGNALS:
-                void nameChanged();
                 void penChanged();
                 void brushChanged();
                 void labelChanged();
                 void labelBrushChanged();
                 void labelFontChanged();
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void valueChanged(int index);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)
                 friend class QBarSeries;
                 friend class BarLegendMarker;
                 friend class BarChartItem;
                 friend class QBarSeriesPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/qbarset_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARSET_P_H
             #define QBARSET_P_H
             #include "qbarset.h"
             #include <QMap>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate : public QObject
             {
                 Q_OBJECT
             public:
-                QBarSetPrivate(const QString name, QBarSet *parent);
+                QBarSetPrivate(const QString label, QBarSet *parent);
                 ~QBarSetPrivate();
                 void append(QPointF value);
                 void append(QList<QPointF> values);
                 void append(QList<qreal> values);
                 void insert(const int index, const qreal value);
                 void insert(const int index, const QPointF value);
                 bool remove(const int index, const int count);
                 void replace(const int index, const qreal value);
                 void replace(const int index, const QPointF value);
             Q_SIGNALS:
                 void restructuredBars();
                 void updatedBars();
             public:
                 QBarSet * const q_ptr;
-                QString m_name;
+                QString m_label;
                 QList<QPointF> m_values;
                 QPen m_pen;
                 QBrush m_brush;
                 QBrush m_labelBrush;
                 QFont m_labelFont;
                 friend class QBarSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSETPRIVATE_P_H

src/legend/legendmarker.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 "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) :
                 QGraphicsObject(legend),
                 m_series(series),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this))
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
                 updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_textItem->setPen(pen);
                 updateLayout();
             }
             QPen LegendMarker::pen() const
             {
                 return m_textItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
-            void LegendMarker::setLabel(const QString name)
+            void LegendMarker::setLabel(const QString label)
             {
-                m_textItem->setText(name);
+                m_textItem->setText(label);
                 updateLayout();
             }
             void LegendMarker::setSize(const QSize& size)
             {
                 m_markerRect = QRectF(0,0,size.width(),size.height());
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::updateLayout()
             {
                 static const qreal margin = 2;
                 static const qreal space = 4;
                 const QRectF& textRect = m_textItem->boundingRect();
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
                 m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
                 m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
-                setLabel(m_barset->name());
+                setLabel(m_barset->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qbarset/tst_qbarset.cpp +15 -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 <qbarset.h>
             #include <qgroupedbarseries.h>
             #include <qchartview.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QBarSet : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarset_data();
                 void qbarset();
-                void name_data();
+                void label_data();
-                void name();
+                void label();
                 void append_data();
                 void append();
                 void appendOperator_data();
                 void appendOperator();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 void replace_data();
                 void replace();
                 void at_data();
                 void at();
                 void atOperator_data();
                 void atOperator();
                 void count_data();
                 void count();
                 void sum_data();
                 void sum();
                 void customize();
             private:
                 QBarSet* m_barset;
             };
             void tst_QBarSet::initTestCase()
             {
             }
             void tst_QBarSet::cleanupTestCase()
             {
             }
             void tst_QBarSet::init()
             {
-                 m_barset = new QBarSet(QString("Name"));
+                 m_barset = new QBarSet(QString("label"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
-                QBarSet barset(QString("Name"));
+                QBarSet barset(QString("label"));
-                QCOMPARE(barset.name(), QString("Name"));
+                QCOMPARE(barset.label(), QString("label"));
                 QCOMPARE(barset.count(), 0);
                 QVERIFY(qFuzzyIsNull(barset.sum()));
             }
-            void tst_QBarSet::name_data()
+            void tst_QBarSet::label_data()
             {
-                QTest::addColumn<QString> ("name");
+                QTest::addColumn<QString> ("label");
                 QTest::addColumn<QString> ("result");
-                QTest::newRow("name0") << QString("name0") << QString("name0");
+                QTest::newRow("label0") << QString("label0") << QString("label0");
-                QTest::newRow("name1") << QString("name1") << QString("name1");
+                QTest::newRow("label1") << QString("label1") << QString("label1");
             }
-            void tst_QBarSet::name()
+            void tst_QBarSet::label()
             {
-                QFETCH(QString, name);
+                QFETCH(QString, label);
                 QFETCH(QString, result);
-                QSignalSpy nameSpy(m_barset,SIGNAL(nameChanged()));
+                QSignalSpy labelSpy(m_barset,SIGNAL(labelChanged()));
-                m_barset->setName(name);
+                m_barset->setLabel(label);
-                QCOMPARE(m_barset->name(), result);
+                QCOMPARE(m_barset->label(), result);
-                QVERIFY(nameSpy.count() == 1);
+                QVERIFY(labelSpy.count() == 1);
             }
             void tst_QBarSet::append_data()
             {
                 QTest::addColumn<int> ("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("100") << 100;
                 QTest::newRow("1000") << 1000;
             }
             void tst_QBarSet::append()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     m_barset->append(value);
                     QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QVERIFY(valueSpy.count() == count);
             }
             void tst_QBarSet::appendOperator_data()
             {
                 append_data();
             }
             void tst_QBarSet::appendOperator()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     *m_barset << value;
                     QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QVERIFY(valueSpy.count() == count);
             }
             void tst_QBarSet::insert_data()
             {
             }
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 m_barset->insert(0, 1.0);       // 1.0
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->count(), 1);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 1.0));
                 m_barset->insert(0, 2.0);       // 2.0 1.0
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(1).y(), 1.0);
                 QCOMPARE(m_barset->count(), 2);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 3.0));
                 m_barset->insert(1, 3.0);       // 2.0 3.0 1.0
                 QCOMPARE(m_barset->at(1).y(), 3.0);
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 1.0);
                 QCOMPARE(m_barset->count(), 3);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 6.0));
                 QVERIFY(valueSpy.count() == 3);
             }
             void tst_QBarSet::remove_data()
             {
             }
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesRemoved(int,int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->remove(2);                // 1.0 2.0 4.0
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 4.0);
                 QCOMPARE(m_barset->count(), 3);
                 QCOMPARE(m_barset->sum(), 7.0);
                 m_barset->remove(0);                // 2.0 4.0
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(1).y(), 4.0);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 QVERIFY(valueSpy.count() == 2);
             }
             void tst_QBarSet::replace_data()
             {
             }
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valueChanged(int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->replace(0, 5.0);          // 5.0 2.0 3.0 4.0
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 14.0);
                 QCOMPARE(m_barset->at(0).y(), 5.0);
                 m_barset->replace(3, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QCOMPARE(m_barset->at(0).y(), 5.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 3.0);
                 QCOMPARE(m_barset->at(3).y(), 6.0);
                 QVERIFY(valueSpy.count() == 2);
             }
             void tst_QBarSet::at_data()
             {
             }
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 3.0);
                 QCOMPARE(m_barset->at(3).y(), 4.0);
             }
             void tst_QBarSet::atOperator_data()
             {
             }
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->operator [](0).y(), 1.0);
                 QCOMPARE(m_barset->operator [](1).y(), 2.0);
                 QCOMPARE(m_barset->operator [](2).y(), 3.0);
                 QCOMPARE(m_barset->operator [](3).y(), 4.0);
             }
             void tst_QBarSet::count_data()
             {
             }
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
                 m_barset->append(2.0);
                 QCOMPARE(m_barset->count(),2);
                 m_barset->append(3.0);
                 QCOMPARE(m_barset->count(),3);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(),4);
             }
             void tst_QBarSet::sum_data()
             {
             }
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),1.0));
                 m_barset->append(2.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),3.0));
                 m_barset->append(3.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),6.0));
                 m_barset->append(4.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),10.0));
             }
             void tst_QBarSet::customize()
             {
                 // Create sets
                 QBarSet *set1 = new QBarSet("set1");
                 QBarSet *set2 = new QBarSet("set2");
                 // Append set1 to series
                 QGroupedBarSeries *series = new QGroupedBarSeries();
                 bool success = series->append(set1);
                 QVERIFY(success);
                 // Add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
                 // Test pen
                 QVERIFY(set1->pen() != QPen());
                 QVERIFY(set2->pen() == QPen());
                 QPen pen(QColor(128,128,128,128));
                 set1->setPen(pen);
                 QVERIFY(set1->pen() == pen);
                 QVERIFY(set2->pen() == QPen());
                 // Test brush
                 QVERIFY(set1->brush() != QBrush());
                 QVERIFY(set2->brush() == QBrush());
                 QBrush brush(QColor(128,128,128,128));
                 set1->setBrush(brush);
                 QVERIFY(set1->brush() == brush);
                 QVERIFY(set2->brush() == QBrush());
                 // Test label brush
                 QVERIFY(set1->labelBrush() != QBrush());
                 QVERIFY(set2->labelBrush() == QBrush());
                 set1->setLabelBrush(brush);
                 QVERIFY(set1->labelBrush() == brush);
                 QVERIFY(set2->labelBrush() == QBrush());
                 // Test label font
                 // Note: QFont empty constructor creates font with application's default font, so the font may or may not be the
                 // same for the set added to the series  (depending on the QChart's theme configuration)
                 QVERIFY(set1->labelFont() != QFont() || set1->labelFont() == QFont());
                 QVERIFY(set2->labelFont() == QFont());
                 QFont font;
                 font.setBold(true);
                 font.setItalic(true);
                 set1->setLabelFont(font);
                 QVERIFY(set1->labelFont() == font);
                 QVERIFY(set2->labelFont() == QFont());
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
             }
             QTEST_MAIN(tst_QBarSet)
             #include "tst_qbarset.moc"

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