HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1246:5512aa7e284d

removed barlabel. label visibility control is now per series instead of per set

sauimone -

r1246:5512aa7e284d

parent child

Context file:

r1246:5512aa7e284d

Collapse all files

src/barchart/barchart.pri 0 -2

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

src/barchart/barchartitem.cpp +18 -11

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

src/barchart/barchartitem_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$
             **
             ****************************************************************************/
             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
-            class BarLabel;
             class QAxisCategories;
             class QChart;
             //typedef QVector<QRectF> BarLayout;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 virtual QVector<QRectF> calculateLayout();
                 void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleModelChanged();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
+                void labelsVisibleChanged(bool visible);
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 bool m_layoutSet;    // True, if component has been laid out.
                 QVector<QRectF> m_layout;
                 // Not owned.
                 QBarSeries *m_series;
                 QList<Bar *> m_bars;
-                QList<BarLabel *> m_labels;
+                QList<QGraphicsSimpleTextItem *> m_labels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/groupedbarchartitem.cpp +1 -2

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

src/barchart/percentbarchartitem.cpp +1 -2

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

src/barchart/qbarseries.cpp +12 -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 "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, QString category)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \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()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 \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 \a categories, which are used to to group the data.
             */
             void QBarSeries::setCategories(QBarCategories categories)
             {
                 Q_D(QBarSeries);
                 d->setCategories(categories);
                 emit d->categoriesUpdated();
             }
             /*!
                 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);
                 if ((d->m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 d->m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 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);
                 if (!d->m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 d->m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 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);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (d->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) {
                     d->m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 }
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 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);
                 bool setsRemoved = false;
                 foreach (QBarSet* set, sets) {
                     if (d->m_barSets.contains(set)) {
                         d->m_barSets.removeOne(set);
                         QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                         setsRemoved = true;
                     }
                 }
                 if (setsRemoved) {
                     emit d->restructuredBars();
                 }
                 return setsRemoved;
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->categories();
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
-                foreach (QBarSet* s, barSets()) {
+                Q_D(QBarSeries);
-                    s->setLabelsVisible(visible);
+                if (d->m_labelsVisible != visible) {
+                    d->m_labelsVisible = visible;
+                    emit d->updatedBars();
+                }
             }
+            bool QBarSeries::isLabelsVisible() const
+            {
+                Q_D(const QBarSeries);
+                return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
-                m_barMargin(0.05)  // Default value is 5% of category width
+                m_barMargin(0.05),  // Default value is 5% of category width
+                m_labelsVisible(false)
             {
             }
             void QBarSeriesPrivate::setCategories(QBarCategories 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;
             }
             QBarCategories QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
                 QBarCategories 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()
             {
                 return m_barMargin;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             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::barsetChanged()
             {
                 emit updatedBars();
             }
             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;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +1 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
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarCategory;
             class QBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setCategories(QBarCategories categories);
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
+                bool isLabelsVisible() const;
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void hovered(QBarSet* barset, bool status);
             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 +3 0

             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
             // Container for series
             class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarSeries *parent);
                 void setCategories(QBarCategories categories);
                 void insertCategory(int index, const QString category);
                 void removeCategory(int index);
                 int categoryCount() const;
                 QBarCategories categories() const;
                 void setBarMargin(qreal margin);
                 qreal barMargin();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 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, QString category);
                 void updatedBars();
                 void restructuredBars();
                 void categoriesUpdated();
+                void labelsVisibleChanged(bool visible);
             private Q_SLOTS:
                 void barsetChanged();
             protected:
                 QList<QBarSet *> m_barSets;
                 QBarCategories m_categories;
                 qreal m_barMargin;
+                bool m_labelsVisible;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/barchart/qbarset.cpp +1 -22

             /****************************************************************************
             **
             ** 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
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 \brief signals that mouse has hovered over the set. If \a status is true, then mouse was entered. If \a status is false, then mouse was left.
                 The signal is emitted if mouse is hovered on top of set
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 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;
             }
             /*!
                 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);
                 emit d_ptr->restructuredBars();
             }
             /*!
                 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++) {
                     d_ptr->m_values.append(values.at(i));
                 }
                 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)
             {
                 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->m_values.append(QPointF(index,values.at(i)));
                     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));
             //    emit d_ptr->updatedBars();
             }
             /*!
                 Removes the value specified by \a index
                 \sa insert()
             */
             void QBarSet::remove(const int index)
             {
                 d_ptr->m_values.removeAt(index);
             //    emit d_ptr->updatedBars();
             }
             /*!
                 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));
                 emit d_ptr->updatedBars();
             }
             /*!
                 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();
                   }
             }
             /*!
                 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();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a pen of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelPen(const QPen &pen)
             {
                 if(d_ptr->m_labelPen!=pen){
                     d_ptr->m_labelPen = pen;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns pen of the values that are drawn on top of this barset
             */
             QPen QBarSet::labelPen() const
             {
                 return d_ptr->m_labelPen;
             }
             /*!
                 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();
                 }
             }
             /*!
                 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();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
-            /*!
-                Sets visibility of bar labels. If \a visible is true, labels are drawn on top of barsets.
-            */
-            void QBarSet::setLabelsVisible(bool visible)
-                if(d_ptr->m_labelsVisible!=visible) {
-                    d_ptr->m_labelsVisible = visible;
-                    emit d_ptr->labelsVisibleChanged(visible);
-            /*!
-                Returns the visibility of values
-            */
-            bool QBarSet::labelsVisible() const
-                return d_ptr->m_labelsVisible;
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString name, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
-                m_name(name),
+                m_name(name)
-                m_labelsVisible(false)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +8 -11

             /****************************************************************************
             **
             ** 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)
             public:
                 explicit QBarSet(const QString name, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setName(const QString name);
                 QString name() const;
-                void append(const QPointF value);           // Appends bar with x-value
+                void append(const QPointF value);
-                void append(const QList<QPointF> values);   // Same with list
+                void append(const QList<QPointF> values);
-                void append(const qreal value);             // TODO: change so, that count becomes x-value
+                void append(const qreal value);
-                void append(const QList<qreal> values);     // Append list of values. Using index as x-value
+                void append(const QList<qreal> values);
-                QBarSet& operator << (const qreal &value);      // TODO: change implementations so, that count becomes x-value
+                QBarSet& operator << (const qreal &value);
-                QBarSet& operator << (const QPointF &value);    // Appends bar with x-value
+                QBarSet& operator << (const QPointF &value);
-                void insert(const int index, const qreal value); // TODO: internal reindexing (what happens, if there are points with real x values?)
+                void insert(const int index, const qreal value);
-                void remove(const int index);                    // TODO: internal reindexing (what happens, if there are points with real x values?)
+                void remove(const int index);
                 void replace(const int index, const qreal 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 setLabelPen(const QPen &pen);
                 QPen labelPen() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
-                void setLabelsVisible(bool visible = true);
-                bool labelsVisible() const;
             Q_SIGNALS:
                 void clicked(QString category);
                 void hovered(bool status);
             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 +3 -2

             #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();
             Q_SIGNALS:
                 void clicked(QString category);
                 void restructuredBars();
                 void updatedBars();
-                void labelsVisibleChanged(bool visible);
             public:
                 QBarSet * const q_ptr;
                 QString m_name;
                 QList<QPointF> m_values;
                 QPen m_pen;
                 QBrush m_brush;
                 QPen m_labelPen;
                 QBrush m_labelBrush;
                 QFont m_labelFont;
-                bool m_labelsVisible;
                 friend class QBarSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSETPRIVATE_P_H

src/barchart/stackedbarchartitem.cpp +1 -2

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

tests/auto/qbarseries/tst_qbarseries.cpp +8 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarseries_data();
                 void qbarseries();
                 void type_data();
                 void type();
                 void setCategories_data();
                 void setCategories();
                 void append_data();
                 void append();
                 void remove_data();
                 void remove();
                 void appendList_data();
                 void appendList();
                 void removeList_data();
                 void removeList();
                 void barsetCount_data();
                 void barsetCount();
                 void categoryCount_data();
                 void categoryCount();
                 void barSets_data();
                 void barSets();
                 void categories_data();
                 void categories();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QBarSeries* m_barseries;
                 QBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
                 QBarCategories m_categories;
             };
             void tst_QBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
             }
             void tst_QBarSeries::init()
             {
                 m_categories << "category0" << "category1" << "category2";
                 m_barseries = new QBarSeries();
                 m_barseries->setCategories(m_categories);
                 m_barseries_with_sets = new QBarSeries();
                 m_barseries_with_sets->setCategories(m_categories);
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
                     m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::cleanup()
             {
                 foreach(QBarSet* s, m_testSets) {
                     m_barseries_with_sets->remove(s);
                     delete s;
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
                 m_categories.clear();
             }
             void tst_QBarSeries::qbarseries_data()
             {
                 QTest::addColumn<QBarCategories> ("categories");
                 QBarCategories c;
                 c << "category0" << "category1" << "category2";
                 QTest::newRow("categories") << c;
             }
             void tst_QBarSeries::qbarseries()
             {
                 QFETCH(QBarCategories, categories);
                 QBarSeries *barseries = new QBarSeries();
                 QVERIFY(barseries != 0);
                 barseries->setCategories(categories);
                 QBarCategories verifyCategories = barseries->categories();
                 QVERIFY(verifyCategories.count() == categories.count());
                 for (int i=0; i<categories.count(); i++) {
                     QVERIFY(verifyCategories.at(i).compare(categories.at(i)) == 0);
                 }
             }
             void tst_QBarSeries::type_data()
             {
             }
             void tst_QBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
             void tst_QBarSeries::setCategories_data()
             {
                 QTest::addColumn<QBarCategories> ("categories");
                 QBarCategories categories;
                 categories << "c1" << "c2" << "c3" << "c4" << "c5" << "c6";
                 QTest::newRow("cat") << categories;
             }
             void tst_QBarSeries::setCategories()
             {
                 QVERIFY(m_barseries->categories().count() == m_categories.count());
                 QFETCH(QBarCategories, categories);
                 m_barseries->setCategories(categories);
                 QVERIFY(m_barseries->categories().count() == categories.count());
                 for (int i=0; i<categories.count(); i++) {
                     QVERIFY(m_barseries->categories().at(i).compare(categories.at(i)) == 0);
                 }
             }
             void tst_QBarSeries::append_data()
             {
             }
             void tst_QBarSeries::append()
             {
                 QVERIFY(m_barseries->barsetCount() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
                 ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == 2);
                 // Try adding same set again
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == 2);
                 // Try adding null set
                 ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == 2);
             }
             void tst_QBarSeries::remove_data()
             {
             }
             void tst_QBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
                 ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
                 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // remove some sets
                 ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
                     ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
             }
             void tst_QBarSeries::appendList_data()
             {
             }
             void tst_QBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->barsetCount() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Append same sets again (should fail, count should remain same)
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
                 ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
             }
             void tst_QBarSeries::removeList_data()
             {
             }
             void tst_QBarSeries::removeList()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try removing empty list of sets (should return false, since no barsets were removed)
                 bool ret = false;
                 QList<QBarSet*> invalidList;
                 ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Add some null pointers to list
                 invalidList.append(0);
                 invalidList.append(0);
                 invalidList.append(0);
                 // Try removing null pointers from list (should return false, should not crash, should not remove anything)
                 ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // remove all sets (should return true, since sets were removed)
                 ret = m_barseries_with_sets->remove(m_testSets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
                 // Try removing invalid list again (should return false, since no barsets were removed)
                 ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
                 // remove all sets again (should return false, since barsets were already removed)
                 ret = m_barseries_with_sets->remove(m_testSets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
             }
             void tst_QBarSeries::barsetCount_data()
             {
             }
             void tst_QBarSeries::barsetCount()
             {
                 QVERIFY(m_barseries->barsetCount() == 0);
                 QVERIFY(m_barseries_with_sets->barsetCount() == m_testSets.count());
             }
             void tst_QBarSeries::categoryCount_data()
             {
             }
             void tst_QBarSeries::categoryCount()
             {
                 QVERIFY(m_barseries->categoryCount() == m_categories.count());
                 QVERIFY(m_barseries_with_sets->categoryCount() == m_categories.count());
             }
             void tst_QBarSeries::barSets_data()
             {
             }
             void tst_QBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::categories_data()
             {
             }
             void tst_QBarSeries::categories()
             {
                 QBarCategories categories = m_barseries->categories();
                 QVERIFY(categories.count() == m_categories.count());
                 for (int i=0; i<m_categories.count(); i++) {
                     QVERIFY(categories.at(i).compare(m_categories.at(i)) == 0);
                 }
             }
             void tst_QBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
-                foreach (QBarSet* s, m_testSets) {
+                QVERIFY(m_barseries->isLabelsVisible() == false);
-                    QVERIFY(s->labelsVisible() == false);
+                QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
-                foreach (QBarSet* s, m_testSets) {
+                // TODO: test the signal
-                    QVERIFY(s->labelsVisible() == true);
+                QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
-                foreach (QBarSet* s, m_testSets) {
+                // TODO: test the signal
-                    QVERIFY(s->labelsVisible() == false);
+                QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
-                foreach (QBarSet* s, m_testSets) {
+                // TODO: test the signal
-                    QVERIFY(s->labelsVisible() == true);
+                QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
             }
             void tst_QBarSeries::mouseclicked_data()
             {
             }
             void tst_QBarSeries::mouseclicked()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(105,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(295,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(145,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(240,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(335,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // no event cases
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1));     // Outside of both sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1));    // Right mouse button outside and inside sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(105,180)); // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(200,180)); // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(295,180)); // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(145,180)); // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(240,180)); // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(335,180)); // barset 2, category test3
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 0);
             }
             void tst_QBarSeries::mousehovered_data()
             {
             }
             void tst_QBarSeries::mousehovered()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0.1,10) << QPointF(1.1,10) << QPointF(2.1,10);
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(105,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(145,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 2);
                 // should leave set1
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(175,180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 1);
                 // should leave set2 (event via set)
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should leave set2 (event via series)
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
             }
             /*
             bool setModel(QAbstractItemModel *model);
             void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             void setModelMappingRange(int first, int count = -1);
             */
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

src/barchart/barlabel.cpp removed 0 -104

NO CONTENT: file was removed

src/barchart/barlabel_p.h removed 0 -70

NO CONTENT: file was removed

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