HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1353:e34fe2671696

barchart signals for properties and changes

sauimone -

r1353:e34fe2671696

parent child

Context file:

r1353:e34fe2671696

Collapse all files

src/barchart/qbarseries.cpp +41 -17

             /****************************************************************************
             **
             ** 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
             */
             /*!
                 \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.
             */
             /*!
                 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 margin around bars. Parameter \a margin is from 0 to 1 and represents
                 percentage of margin compared to bars
             */
             void QBarSeries::setBarMargin(qreal margin)
             {
                 Q_D(QBarSeries);
                 d->setBarMargin(margin);
             }
             /*!
                 Returns the margin around bars
             */
             qreal QBarSeries::barMargin() const
             {
                 Q_D(const QBarSeries);
                 return d->barMargin();
             }
             /*!
                 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);
-                return d->append(set);
+                bool success = d->append(set);
+                if (success) {
+                    QList<QBarSet*> sets;
+                    sets.append(set);
+                    emit barsetsAdded(sets);
+                }
+                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);
-                return d->remove(set);
+                bool success = d->remove(set);
+                if (success) {
+                    QList<QBarSet*> sets;
+                    sets.append(set);
+                    emit barsetsRemoved(sets);
+                }
+                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);
-                return d->append(sets);
+                bool success = d->append(sets);
+                if (success) {
+                    emit barsetsAdded(sets);
+                }
+                return success;
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
             bool QBarSeries::remove(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
-                return d->remove(sets);
+                bool success = d->remove(sets);
+                if (success) {
+                    emit barsetsRemoved(sets);
+                }
+                return success;
             }
             void QBarSeries::clear()
             {
                 Q_D(QBarSeries);
                 d->m_barSets.clear();
             }
             /*!
                 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->m_labelsVisible = visible;
+                    d->setLabelsVisible(visible);
-                    emit d->labelsVisibleChanged(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_barMargin(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::setBarMargin(qreal margin)
             {
                 if (margin > 1.0) {
                     margin = 1.0;
                 } else if (margin < 0.0) {
                     margin = 0.0;
                 }
                 m_barMargin = margin;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barMargin() const
             {
                 return m_barMargin;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
-                if (m_visible != visible) {
                 m_visible = visible;
                 emit updatedBars();
             }
-            bool QBarSeriesPrivate::isVisible() const
+            void QBarSeriesPrivate::setLabelsVisible(bool visible)
             {
-                return m_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;
             }
             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 x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, x) - 0.5;
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x) - 0.5;
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* 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);
-                bool setsRemoved = false;
                 foreach (QBarSet* set, sets) {
-                    if (m_barSets.contains(set)) {
+                    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()));
-                        setsRemoved = true;
                 }
-                if (setsRemoved) {
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
+                return true;
-                return setsRemoved;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +5 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$
             **
             ****************************************************************************/
             #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 barMargin READ barMargin WRITE setBarMargin)
                 Q_PROPERTY(int count READ barsetCount)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible)
             public:
                 explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setBarMargin(qreal margin);
                 qreal barMargin() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 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 visibleChanged();
+                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/qbarseries_p.h +1 -1

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

src/barchart/qbarset.cpp +107 -18

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(const QString name, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(name,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(const QString name)
             {
                 d_ptr->m_name = name;
+                emit nameChanged();
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 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)
             {
-                d_ptr->m_values.append(value);
+                int index = d_ptr->m_values.count();
-                emit d_ptr->restructuredBars();
+                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)
             {
-                for (int i=0; i<values.count(); i++) {
+                int index = d_ptr->m_values.count();
-                    d_ptr->m_values.append(values.at(i));
+                d_ptr->append(values);
+                emit valuesAdded(index, values.count());
-                emit d_ptr->restructuredBars();
             }
             /*!
                 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 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();
-                for (int i=0; i<values.count(); i++) {
+                d_ptr->append(values);
-                    d_ptr->m_values.append(QPointF(index,values.at(i)));
+                emit valuesAdded(index, values.count());
-                    index++;
-                emit d_ptr->restructuredBars();
             }
             /*!
                 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->m_values.insert(index, QPointF(index, value));
+                d_ptr->insert(index, value);
-            //    emit d_ptr->updatedBars();
+                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 the value specified by \a index
                 \sa insert()
             */
-            void QBarSet::remove(const int index)
+            bool QBarSet::remove(const int index, const int count)
             {
-                d_ptr->m_values.removeAt(index);
+                bool success = d_ptr->remove(index,count);
-            //    emit d_ptr->updatedBars();
+                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->m_values.replace(index,QPointF(index,value));
+                d_ptr->replace(index,value);
-                emit d_ptr->updatedBars();
+                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),
                 q_ptr(parent),
                 m_name(name)
             {
             }
             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 +15 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
                 Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush)
                 Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont)
             public:
                 explicit QBarSet(const QString name, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setName(const QString name);
                 QString name() 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 remove(const int index);
+                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 +11 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$
             **
             ****************************************************************************/
             //  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();
+                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;
                 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

tests/auto/qbarset/tst_qbarset.cpp +19 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 <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 name();
                 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"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
                 QBarSet barset(QString("Name"));
                 QCOMPARE(barset.name(), QString("Name"));
                 QCOMPARE(barset.count(), 0);
                 QVERIFY(qFuzzyIsNull(barset.sum()));
             }
             void tst_QBarSet::name_data()
             {
                 QTest::addColumn<QString> ("name");
                 QTest::addColumn<QString> ("result");
                 QTest::newRow("name0") << QString("name0") << QString("name0");
                 QTest::newRow("name1") << QString("name1") << QString("name1");
             }
             void tst_QBarSet::name()
             {
                 QFETCH(QString, name);
                 QFETCH(QString, result);
+                QSignalSpy nameSpy(m_barset,SIGNAL(nameChanged()));
                 m_barset->setName(name);
                 QCOMPARE(m_barset->name(), result);
+                QVERIFY(nameSpy.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