HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2067:10f778f66485

Added opacity property to QAbstractSeries

Tero Ahola -

r2067:10f778f66485

parent child

Context file:

r2067:10f778f66485

Expand all files

plugins/declarative/plugin.cpp +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$
             **
             ****************************************************************************/
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/qdeclarativeextensionplugin.h>
                 #include <QtQuick1/qdeclarative.h>
             #else
                 #include <QtDeclarative/qdeclarativeextensionplugin.h>
                 #include <QtDeclarative/qdeclarative.h>
             #endif
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include "declarativemargins.h"
             #include <QAbstractItemModel>
             #ifndef QT_ON_ARM
             #include "qdatetimeaxis.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             #ifdef QT5_QUICK_1
+                // TODO: fix the metadata
                 Q_PLUGIN_METADATA(IID "org.qt-project.foo")
             #endif
                 public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     // QtCommercial.Chart 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 1, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 1, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 1, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 1, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 1, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 1, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 1, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 1, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 1, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 1, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 1, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 1, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 1, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 1, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 1, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 1, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 1, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 1, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 1, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #ifndef QT5_QUICK_1
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

src/areachart/areachartitem.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
                 : ChartItem(presenter),
                 m_series(areaSeries),
                 m_upper(0),
                 m_lower(0),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries(),presenter);
                 if (m_series->lowerSeries()){
                     m_lower = new AreaBoundItem(this,m_series->lowerSeries(),presenter);
                 }
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
+                QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path = m_upper->path();
                 if (m_lower) {
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path = path;
                 m_rect = path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
+                setOpacity(m_series->opacity());
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 m_upper->setDomain(domain());
                 m_upper->handleDomainUpdated();
                 if (m_lower){
                     m_lower->setDomain(domain());
                     m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if (m_lower)
                     m_lower->handleGeometryChanged(rect);
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->geometryPoints());
                        if (m_lower)
                            painter->drawPoints(m_lower->geometryPoints());
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->calculateDomainPoint(event->pos()));
                 ChartItem::mousePressEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem.cpp +8 -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 "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             #include "abstractbaranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
+                connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (m_animation) {
                     m_animation->setup(m_layout,layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             void AbstractBarChartItem::setAnimation(AbstractBarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                 }
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem* label, m_labels) {
                     label->setVisible(visible);
                 }
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 bool labelsVisible = m_series->isLabelsVisible();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set,c,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), m_series, SIGNAL(hovered(bool,QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), set, SIGNAL(hovered(bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                         // Labels
                         QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
                         label->setVisible(labelsVisible);
                         m_labels.append(label);
                     }
                 }
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 handleLabelsVisibleChanged(visible);
-                foreach(QGraphicsItem *item, childItems()) {
+                foreach(QGraphicsItem *item, childItems())
                     item->setVisible(visible);
+            }
+            void AbstractBarChartItem::handleOpacityChanged()
+            {
+                foreach(QGraphicsItem *item, childItems())
+                    item->setOpacity(m_series->opacity());
             }
             void AbstractBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem_p.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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef ABSTRACTBARCHARTITEM_H
             #define ABSTRACTBARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qabstractbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
             class AbstractBarAnimation;
             class AbstractBarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 AbstractBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
                 virtual ~AbstractBarChartItem();
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual QVector<QRectF> calculateLayout() = 0;
                 virtual void applyLayout(const QVector<QRectF> &layout);
                 virtual void setAnimation(AbstractBarAnimation* animation);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleDomainUpdated();
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items
                 void handleVisibleChanged();
+                void handleOpacityChanged();
                 void handleUpdatedBars();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
                 AbstractBarAnimation *m_animation;
                 QAbstractBarSeries *m_series; // Not owned.
                 QList<Bar *> m_bars;
                 QList<QGraphicsSimpleTextItem *> m_labels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTBARCHARTITEM_H

src/linechart/linechartitem.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const qreal mouseEventMinWidth(12);
             LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):
                 XYChart(series, presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
+                QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::updateGeometry()
             {
                 m_points = geometryPoints();
                 if(m_points.size()==0)
                 {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 QPainterPath linePath(m_points.at(0));
                 if(m_pointsVisible) {
                     int size = m_linePen.width();
                     linePath.addEllipse(m_points.at(0),size,size);
                     for(int i=1; i< m_points.size();i++) {
                         linePath.lineTo(m_points.at(i));
                         linePath.addEllipse(m_points.at(i),size,size);
                     }
                 } else {
                     for(int i=1; i< m_points.size();i++) {
                         linePath.lineTo(m_points.at(i));
                     }
                 }
                 m_linePath = linePath;
                 QPainterPathStroker stroker;
                 // QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
                 // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
                 // multiply line width with square root of two when defining shape and bounding rectangle.
                 stroker.setWidth(m_linePen.width() * 1.42);
                 stroker.setJoinStyle(Qt::MiterJoin);
                 stroker.setCapStyle(Qt::SquareCap);
                 stroker.setMiterLimit(m_linePen.miterLimit());
                 prepareGeometryChange();
                 m_path = stroker.createStroke(linePath);
                 m_rect = m_path.boundingRect();
                 setPos(origin());
             }
             void LineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
+                setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 update();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_linePen.color());
                 painter->setClipRect(clipRect());
                 if (m_pointsVisible) {
                     painter->drawPath(m_linePath);
                 }
                 else {
                     for (int i(1); i < m_points.size();i++)
                         painter->drawLine(m_points.at(i-1), m_points.at(i));
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +6 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "pieanimation_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series),
                 m_animation(0)
             {
                 Q_ASSERT(series);
                 QPieSeriesPrivate *p = QPieSeriesPrivate::fromSeries(series);
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
+                connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(p, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 // Note: will not create slice items until we have a proper rectangle to draw on.
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::setAnimation(PieAnimation* animation)
             {
                 m_animation=animation;
             }
             ChartAnimation* PieChartItem::animation() const
             {
                 return m_animation;
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 updateLayout();
                 // This is for delayed initialization of the slice items during startup.
                 // It ensures that startup animation originates from the correct position.
                 if (m_sliceItems.isEmpty())
                     handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 // does not apply to pie
             }
             void PieChartItem::handleDomainUpdated()
             {
                 // does not apply to pie
             }
             void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 // does not apply to pie
             }
             void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 // does not apply to pie
             }
             void PieChartItem::updateLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 m_holeSize = m_pieRadius;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
                 m_holeSize *= m_series->holeSize();
                 // set layouts for existing slice items
                 foreach (QPieSlice* slice, m_series->slices()) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     if (sliceItem) {
                         PieSliceData sliceData = updateSliceGeometry(slice);
                         if (m_animation){
                             presenter()->startAnimation(m_animation->updateValue(sliceItem, sliceData));
                         }
                         else
                             sliceItem->setLayout(sliceData);
                     }
                 }
                 update();
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                     return;
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 bool startupAnimation = m_sliceItems.isEmpty();
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem* sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
                     // Note: no need to connect to slice valueChanged() etc.
                     // This is handled through calculatedDataChanged signal.
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelVisibleChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(penChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(brushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelBrushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelFontChanged()), this, SLOT(handleSliceChanged()));
                     QPieSlicePrivate *p = QPieSlicePrivate::fromSlice(slice);
                     connect(p, SIGNAL(labelPositionChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodedChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodeDistanceFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked()));
                     connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool)));
                     PieSliceData sliceData = updateSliceGeometry(slice);
                     if (m_animation)
                         presenter()->startAnimation(m_animation->addSlice(sliceItem, sliceData, startupAnimation));
                     else
                         sliceItem->setLayout(sliceData);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     // this can happen if you call append() & remove() in a row so that PieSliceItem is not even created
                     if (!sliceItem)
                         continue;
                     m_sliceItems.remove(slice);
                     if (m_animation)
                         presenter()->startAnimation(m_animation->removeSlice(sliceItem)); // animator deletes the PieSliceItem
                     else
                         delete sliceItem;
                 }
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 if (!slice) {
                     QPieSlicePrivate* slicep = qobject_cast<QPieSlicePrivate *>(sender());
                     slice = slicep->q_ptr;
                 }
                 Q_ASSERT(m_sliceItems.contains(slice));
                 PieSliceItem *sliceItem = m_sliceItems.value(slice);
                 PieSliceData sliceData = updateSliceGeometry(slice);
                 if (m_animation)
                     presenter()->startAnimation(m_animation->updateValue(sliceItem, sliceData));
                 else
                     sliceItem->setLayout(sliceData);
                 update();
             }
             void PieChartItem::handleSeriesVisibleChanged()
             {
                 setVisible(m_series->isVisible());
             }
+            void PieChartItem::handleOpacityChanged()
+            {
+                setOpacity(m_series->opacity());
+            }
             PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
                 PieSliceData &sliceData = QPieSlicePrivate::fromSlice(slice)->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 sliceData.m_holeRadius = m_holeSize;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "piesliceitem_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class ChartPresenter;
             class PieAnimation;
             class PieChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 explicit PieChartItem(QPieSeries *series, ChartPresenter *presenter);
                 ~PieChartItem();
                 // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public Q_SLOTS:
                 // from Chart
                 virtual void handleGeometryChanged(const QRectF &rect);
                 virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 virtual void handleDomainUpdated();
                 virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
                 virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void updateLayout();
                 void handleSlicesAdded(QList<QPieSlice*> slices);
                 void handleSlicesRemoved(QList<QPieSlice*> slices);
                 void handleSliceChanged();
                 void handleSeriesVisibleChanged();
+                void handleOpacityChanged();
                 void setAnimation(PieAnimation* animation);
                 ChartAnimation* animation() const;
             private:
                 PieSliceData updateSliceGeometry(QPieSlice *slice);
             private:
                 QHash<QPieSlice*, PieSliceItem*> m_sliceItems;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
                 qreal m_holeSize;
                 PieAnimation* m_animation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/qabstractseries.cpp +15 -1

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

src/qabstractseries.h +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QABSTRACTSERIES_H
             #define QABSTRACTSERIES_H
             #include <qchartglobal.h>
             #include <qabstractaxis.h>
             #include <QObject>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeriesPrivate;
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QAbstractSeries : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
+                Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
                 Q_PROPERTY(SeriesType type READ type)
                 Q_ENUMS(SeriesType)
             public:
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             protected:
                 QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractSeries();
                 virtual SeriesType type() const = 0;
                 void setName(const QString& name);
                 QString name() const;
                 void setVisible(bool visible = true);
                 bool isVisible() const;
+                qreal opacity() const;
+                void setOpacity(qreal opacity);
                 QChart* chart() const;
                 void show();
                 void hide();
             Q_SIGNALS:
                 void nameChanged();
                 void visibleChanged();
+                void opacityChanged();
             protected:
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
                 friend class DeclarativeChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTSERIES_H

src/qabstractseries_p.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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include "qabstractseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class ChartPresenter;
             class ChartElement;
             class LegendMarker;
             class QLegend;
             class ChartDataSet;
             class QAbstractAxis;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void scaleDomain(Domain& domain) = 0;
                 virtual ChartElement* createGraphics(ChartPresenter* presenter) = 0;
                 virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
                 virtual void initializeAxis(QAbstractAxis* axis) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
             protected:
                 QAbstractSeries *q_ptr;
                 QChart *m_chart;
                 ChartDataSet *m_dataset;
                 QString m_name;
                 bool m_visible;
+                qreal m_opacity;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterchart/scatterchartitem.cpp +2 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
                 XYChart(series,presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_items(this),
                 m_visible(true),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
+                QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                         case QScatterSeries::MarkerShapeCircle: {
                             item = new CircleMarker(0,0,m_size,m_size,this);
                             const QRectF& rect = item->boundingRect();
                             item->setPos(-rect.width()/2,-rect.height()/2);
                             break;
                         }
                         case QScatterSeries::MarkerShapeRectangle: {
                             item = new RectangleMarker(0,0,m_size,m_size,this);
                             item->setPos(-m_size/2,-m_size/2);
                             break;
                         }
                         default:
                         qWarning()<<"Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem * item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
             }
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
                 emit XYChart::clicked(calculateDomainPoint(m_markerMap[marker]));
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     QGraphicsItem* item = items.at(i);
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     m_markerMap[item]=point;
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!m_visible || !clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 setPos(origin());
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
                 }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_visible != m_series->isVisible()
                         || m_size != m_series->markerSize()
                         || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
+                setOpacity(m_series->opacity());
                 if(recreate) {
                     // TODO: optimize handleUpdate to recreate points only in case shape changed
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem.cpp +2 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "splineanimation_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
                 XYChart(series, presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_pointsVisible(false),
                 m_animation(0)
             {
                 setZValue(ChartPresenter::SplineChartZValue);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
+                QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             void SplineChartItem::setAnimation(SplineAnimation* animation)
             {
                 m_animation=animation;
                 XYChart::setAnimation(animation);
             }
             ChartAnimation* SplineChartItem::animation() const
             {
                 return m_animation;
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints=points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 QVector<QPointF> controlPoints;
                 if(newPoints.count()>=2) {
                     controlPoints.resize(newPoints.count()*2-2);
                 }
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
                 if (m_animation)
                     m_animation->setup(oldPoints, newPoints, m_controlPoints, controlPoints, index);
                 m_points = newPoints;
                 m_controlPoints = controlPoints;
                 setDirty(false);
                 if (m_animation) {
                     presenter()->startAnimation(m_animation);
                 } else {
                     updateGeometry();
                 }
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChart::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = m_points;
                 const QVector<QPointF> &controlPoints = m_controlPoints;
                 if ((points.size()<2) || (controlPoints.size()<2)) {
                 	prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count()*2-2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 setPos(origin());
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
+                setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qbarseries/tst_qbarseries.cpp +20 0

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

tests/auto/qpieseries/tst_qpieseries.cpp +12 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpiemodelmapper.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QPieSlice*)
             Q_DECLARE_METATYPE(QList<QPieSlice*>)
             class tst_qpieseries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void properties();
                 void append();
                 void appendAnimated();
                 void insert();
                 void insertAnimated();
                 void remove();
                 void removeAnimated();
                 void take();
                 void takeAnimated();
                 void calculatedValues();
                 void clickedSignal();
                 void hoverSignal();
                 void sliceSeries();
                 void destruction();
             private:
                 void verifyCalculatedData(const QPieSeries &series, bool *ok);
                 QList<QPoint> slicePoints(QRectF rect);
             private:
                 QChartView *m_view;
                 QPieSeries *m_series;
             };
             void tst_qpieseries::initTestCase()
             {
                 qRegisterMetaType<QPieSlice*>("QPieSlice*");
                 qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>");
             }
             void tst_qpieseries::cleanupTestCase()
             {
             }
             void tst_qpieseries::init()
             {
                 m_view = new QChartView();
                 m_series = new QPieSeries(m_view);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_qpieseries::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_series = 0;
             }
             void tst_qpieseries::properties()
             {
                 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
                 QSignalSpy sumSpy(m_series, SIGNAL(sumChanged()));
+                QSignalSpy opacitySpy(m_series, SIGNAL(opacityChanged()));
                 QVERIFY(m_series->type() == QAbstractSeries::SeriesTypePie);
                 QVERIFY(m_series->count() == 0);
                 QVERIFY(m_series->isEmpty());
                 QCOMPARE(m_series->sum(), 0.0);
                 QCOMPARE(m_series->horizontalPosition(), 0.5);
                 QCOMPARE(m_series->verticalPosition(), 0.5);
                 QCOMPARE(m_series->pieSize(), 0.7);
                 QCOMPARE(m_series->pieStartAngle(), 0.0);
                 QCOMPARE(m_series->pieEndAngle(), 360.0);
+                QCOMPARE(m_series->opacity(), 1.0);
                 m_series->append("s1", 1);
                 m_series->append("s2", 1);
                 m_series->append("s3", 1);
                 m_series->insert(1, new QPieSlice("s4", 1));
                 m_series->remove(m_series->slices().first());
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(m_series->sum(), 3.0);
                 m_series->clear();
                 QCOMPARE(m_series->count(), 0);
                 QCOMPARE(m_series->sum(), 0.0);
                 QCOMPARE(countSpy.count(), 6);
                 QCOMPARE(sumSpy.count(), 6);
                 m_series->setPieSize(-1.0);
                 QCOMPARE(m_series->pieSize(), 0.0);
                 m_series->setPieSize(0.0);
                 m_series->setPieSize(0.9);
                 m_series->setPieSize(2.0);
                 QCOMPARE(m_series->pieSize(), 1.0);
                 m_series->setPieSize(0.7);
                 QCOMPARE(m_series->pieSize(), 0.7);
                 m_series->setHoleSize(-1.0);
                 QCOMPARE(m_series->holeSize(), 0.0);
                 m_series->setHoleSize(0.5);
                 QCOMPARE(m_series->holeSize(), 0.5);
                 m_series->setHoleSize(0.8);
                 QCOMPARE(m_series->holeSize(), 0.8);
                 QCOMPARE(m_series->pieSize(), 0.8);
                 m_series->setPieSize(0.4);
                 QCOMPARE(m_series->pieSize(), 0.4);
                 QCOMPARE(m_series->holeSize(), 0.4);
                 m_series->setPieStartAngle(0);
                 m_series->setPieStartAngle(-180);
                 m_series->setPieStartAngle(180);
                 QCOMPARE(m_series->pieStartAngle(), 180.0);
                 m_series->setPieEndAngle(360);
                 m_series->setPieEndAngle(-180);
                 m_series->setPieEndAngle(180);
                 QCOMPARE(m_series->pieEndAngle(), 180.0);
                 m_series->setHorizontalPosition(0.5);
                 m_series->setHorizontalPosition(-1.0);
                 QCOMPARE(m_series->horizontalPosition(), 0.0);
                 m_series->setHorizontalPosition(1.0);
                 m_series->setHorizontalPosition(2.0);
                 QCOMPARE(m_series->horizontalPosition(), 1.0);
                 m_series->setVerticalPosition(0.5);
                 m_series->setVerticalPosition(-1.0);
                 QCOMPARE(m_series->verticalPosition(), 0.0);
                 m_series->setVerticalPosition(1.0);
                 m_series->setVerticalPosition(2.0);
                 QCOMPARE(m_series->verticalPosition(), 1.0);
+                m_series->setOpacity(0.5);
+                QCOMPARE(m_series->opacity(), 0.5);
+                QCOMPARE(opacitySpy.count(), 1);
+                m_series->setOpacity(0.0);
+                QCOMPARE(m_series->opacity(), 0.0);
+                QCOMPARE(opacitySpy.count(), 2);
+                m_series->setOpacity(1.0);
+                QCOMPARE(m_series->opacity(), 1.0);
+                QCOMPARE(opacitySpy.count(), 3);
             }
             void tst_qpieseries::append()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
                 // append pointer
                 QPieSlice *slice1 = 0;
                 QVERIFY(!m_series->append(slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(m_series->append(slice1));
                 QVERIFY(!m_series->append(slice1));
                 QCOMPARE(m_series->count(), 1);
                 QCOMPARE(addedSpy.count(), 1);
                 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice1);
                 // try to append same slice to another series
                 QPieSeries series2;
                 QVERIFY(!series2.append(slice1));
                 // append pointer list
                 QList<QPieSlice *> list;
                 QVERIFY(!m_series->append(list));
                 list << (QPieSlice *) 0;
                 QVERIFY(!m_series->append(list));
                 list.clear();
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 QVERIFY(m_series->append(list));
                 QVERIFY(!m_series->append(list));
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(addedSpy.count(), 2);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
                 QCOMPARE(added.count(), 2);
                 QCOMPARE(added, list);
                 // append operator
                 QPieSlice *slice4 = new QPieSlice("slice 4", 4);
                 *m_series << slice4;
                 *m_series << slice1; // fails because already added
                 QCOMPARE(m_series->count(), 4);
                 QCOMPARE(addedSpy.count(), 3);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice4);
                 // append with params
                 QPieSlice *slice5 = m_series->append("slice 5", 5);
                 QVERIFY(slice5 != 0);
                 QCOMPARE(slice5->value(), 5.0);
                 QCOMPARE(slice5->label(), QString("slice 5"));
                 QCOMPARE(m_series->count(), 5);
                 QCOMPARE(addedSpy.count(), 4);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice5);
                 // check slices
                 QVERIFY(!m_series->isEmpty());
                 for (int i=0; i<m_series->count(); i++) {
                     QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::appendAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
                 append();
             }
             void tst_qpieseries::insert()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
                 // insert one slice
                 QPieSlice *slice1 = 0;
                 QVERIFY(!m_series->insert(0, slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(!m_series->insert(-1, slice1));
                 QVERIFY(!m_series->insert(5, slice1));
                 QVERIFY(m_series->insert(0, slice1));
                 QVERIFY(!m_series->insert(0, slice1));
                 QCOMPARE(m_series->count(), 1);
                 QCOMPARE(addedSpy.count(), 1);
                 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice1);
                 // try to insert same slice to another series
                 QPieSeries series2;
                 QVERIFY(!series2.insert(0, slice1));
                 // add some more slices
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 QPieSlice *slice4 = m_series->append("slice 4", 4);
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(addedSpy.count(), 3);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice2);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice4);
                 // insert between slices
                 QPieSlice *slice3 = new QPieSlice("slice 3", 3);
                 m_series->insert(2, slice3);
                 QCOMPARE(m_series->count(), 4);
                 QCOMPARE(addedSpy.count(), 4);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice3);
                 // check slices
                 for (int i=0; i<m_series->count(); i++) {
                     QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                     QVERIFY(m_series->slices().at(i)->parent() == m_series);
                 }
             }
             void tst_qpieseries::insertAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
                 insert();
             }
             void tst_qpieseries::remove()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
                 // add some slices
                 QPieSlice *slice1 = m_series->append("slice 1", 1);
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 QPieSlice *slice3 = m_series->append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 QCOMPARE(m_series->count(), 3);
                 // null pointer remove
                 QVERIFY(!m_series->remove(0));
                 // remove first
                 QVERIFY(m_series->remove(slice1));
                 QVERIFY(!m_series->remove(slice1));
                 QCOMPARE(m_series->count(), 2);
                 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
                 QCOMPARE(removedSpy.count(), 1);
                 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
                 QCOMPARE(removed.count(), 1);
                 QCOMPARE(removed.first(), slice1);
                 // remove all
                 m_series->clear();
                 QVERIFY(m_series->isEmpty());
                 QVERIFY(m_series->slices().isEmpty());
                 QCOMPARE(m_series->count(), 0);
                 QCOMPARE(removedSpy.count(), 2);
                 removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0));
                 QCOMPARE(removed.count(), 2);
                 QCOMPARE(removed.first(), slice2);
                 QCOMPARE(removed.last(), slice3);
                 // check that slices were actually destroyed
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_qpieseries::removeAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
                 remove();
             }
             void tst_qpieseries::take()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
                 // add some slices
                 QPieSlice *slice1 = m_series->append("slice 1", 1);
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 m_series->append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QCOMPARE(m_series->count(), 3);
                 // null pointer remove
                 QVERIFY(!m_series->take(0));
                 // take first
                 QVERIFY(m_series->take(slice1));
                 TRY_COMPARE(spy1.count(), 0);
                 QVERIFY(slice1->parent() == m_series); // series is still the parent object
                 QVERIFY(!m_series->take(slice1));
                 QCOMPARE(m_series->count(), 2);
                 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
                 QCOMPARE(removedSpy.count(), 1);
                 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
                 QCOMPARE(removed.count(), 1);
                 QCOMPARE(removed.first(), slice1);
             }
             void tst_qpieseries::takeAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
                 take();
             }
             void tst_qpieseries::calculatedValues()
             {
                 m_view->chart()->addSeries(m_series);
                 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
                 QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
                 QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
                 QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
                 // add a slice
                 m_series->append(slice1);
                 bool ok;
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 1);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 1);
                 // add some more slices
                 QList<QPieSlice *> list;
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 m_series->append(list);
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 2);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 2);
                 // remove a slice
                 m_series->remove(list.first()); // remove slice 2
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 3);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 3);
                 // insert a slice
                 m_series->insert(0, new QPieSlice("Slice 4", 4));
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 1);
                 QCOMPARE(angleSpanSpy.count(), 4);
                 // modify pie angles
                 m_series->setPieStartAngle(-90);
                 m_series->setPieEndAngle(90);
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 3);
                 QCOMPARE(angleSpanSpy.count(), 6);
                 // clear all
                 m_series->clear();
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 3);
                 QCOMPARE(angleSpanSpy.count(), 6);
             }
             void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
             {
                 *ok = false;
                 qreal sum = 0;
                 foreach (const QPieSlice *slice, series.slices())
                     sum += slice->value();
                 QCOMPARE(series.sum(), sum);
                 qreal startAngle = series.pieStartAngle();
                 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
                 foreach (const QPieSlice *slice, series.slices()) {
                     qreal ratio = slice->value() / sum;
                     qreal sliceSpan = pieAngleSpan * ratio;
                     QCOMPARE(slice->startAngle(), startAngle);
                     QCOMPARE(slice->angleSpan(), sliceSpan);
                     QCOMPARE(slice->percentage(), ratio);
                     startAngle += sliceSpan;
                 }
                 if (!series.isEmpty())
                     QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
                 *ok = true;
             }
             void tst_qpieseries::clickedSignal()
             {
                 // NOTE:
                 // This test is the same as tst_qpieslice::clickedSignal()
                 // Just for different signals.
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 // add some slices
                 QPieSlice *s1 = m_series->append("slice 1", 1);
                 QPieSlice *s2 = m_series->append("slice 2", 1);
                 QPieSlice *s3 = m_series->append("slice 3", 1);
                 QPieSlice *s4 = m_series->append("slice 4", 1);
                 QSignalSpy clickSpy(m_series, SIGNAL(clicked(QPieSlice*)));
                 // add series to the chart
                 m_view->chart()->legend()->setVisible(false);
                 m_view->chart()->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 // test maximum size
                 m_series->setPieSize(1.0);
                 QRectF pieRect = m_view->chart()->plotArea();
                 QList<QPoint> points = slicePoints(pieRect);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
                 TRY_COMPARE(clickSpy.count(), 4);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
                 clickSpy.clear();
                 // test half size
                 m_series->setPieSize(0.5);
                 m_series->setVerticalPosition(0.25);
                 m_series->setHorizontalPosition(0.25);
                 pieRect = QRectF(m_view->chart()->plotArea().topLeft(), m_view->chart()->plotArea().center());
                 points = slicePoints(pieRect);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
                 TRY_COMPARE(clickSpy.count(), 4);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
             }
             void tst_qpieseries::hoverSignal()
             {
                 // NOTE:
                 // This test is the same as tst_qpieslice::hoverSignal()
                 // Just for different signals.
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 // add some slices
                 QPieSlice *s1 = m_series->append("slice 1", 1);
                 QPieSlice *s2 = m_series->append("slice 2", 1);
                 QPieSlice *s3 = m_series->append("slice 3", 1);
                 QPieSlice *s4 = m_series->append("slice 4", 1);
                 // add series to the chart
                 m_view->chart()->legend()->setVisible(false);
                 m_view->chart()->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 // move inside the slices
                 m_series->setPieSize(1.0);
                 QRectF pieRect = m_view->chart()->plotArea();
                 QList<QPoint> points = slicePoints(pieRect);
                 QTest::mouseMove(m_view->viewport(), pieRect.topRight().toPoint());
                 QSignalSpy hoverSpy(m_series, SIGNAL(hovered(QPieSlice*,bool)));
                 QTest::mouseMove(m_view->viewport(), points.at(0));
                 QTest::mouseMove(m_view->viewport(), points.at(1));
                 QTest::mouseMove(m_view->viewport(), points.at(2));
                 QTest::mouseMove(m_view->viewport(), points.at(3));
                 QTest::mouseMove(m_view->viewport(), pieRect.topLeft().toPoint());
                 // check
                 QCOMPARE(hoverSpy.count(), 8);
                 int i = 0;
                 foreach (QPieSlice *s, m_series->slices()) {
                     QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(i).at(0)), s);
                     QCOMPARE(qvariant_cast<bool>(hoverSpy.at(i).at(1)), true);
                     i++;
                     QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(i).at(0)), s);
                     QCOMPARE(qvariant_cast<bool>(hoverSpy.at(i).at(1)), false);
                     i++;
                 }
             }
             void tst_qpieseries::sliceSeries()
             {
                 QPieSlice *slice = new QPieSlice();
                 QVERIFY(!slice->series());
                 delete slice;
                 slice = new QPieSlice(m_series);
                 QVERIFY(!slice->series());
                 m_series->append(slice);
                 QCOMPARE(slice->series(), m_series);
                 slice = new QPieSlice();
                 m_series->insert(0, slice);
                 QCOMPARE(slice->series(), m_series);
                 m_series->take(slice);
                 QCOMPARE(slice->series(), (QPieSeries*) 0);
             }
             void tst_qpieseries::destruction()
             {
                 // add some slices
                 QPieSlice *slice1 = m_series->append("slice 1", 1);
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 QPieSlice *slice3 = m_series->append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 // destroy series
                 delete m_series;
                 m_series = 0;
                 // check that series has destroyed its slices
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
             }
             QList<QPoint> tst_qpieseries::slicePoints(QRectF rect)
             {
                 qreal x1 = rect.topLeft().x() + (rect.width() / 4);
                 qreal x2 = rect.topLeft().x() + (rect.width() / 4) * 3;
                 qreal y1 = rect.topLeft().y() + (rect.height() / 4);
                 qreal y2 = rect.topLeft().y() + (rect.height() / 4) * 3;
                 QList<QPoint> points;
                 points << QPoint(x2, y1);
                 points << QPoint(x2, y2);
                 points << QPoint(x1, y2);
                 points << QPoint(x1, y1);
                 return points;
             }
             QTEST_MAIN(tst_qpieseries)
             #include "tst_qpieseries.moc"

tests/auto/qxyseries/tst_qxyseries.cpp +18 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tst_qxyseries.h"
             Q_DECLARE_METATYPE(QList<QPointF>)
             void tst_QXYSeries::initTestCase()
             {
             }
             void tst_QXYSeries::cleanupTestCase()
             {
             }
             void tst_QXYSeries::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QXYSeries::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
                 m_series = 0;
             }
             void tst_QXYSeries::seriesName()
             {
                 QSignalSpy nameSpy(m_series, SIGNAL(nameChanged()));
                 QCOMPARE(m_series->name(), QString());
                 m_series->setName("seriesname");
                 QCOMPARE(m_series->name(), QString("seriesname"));
                 TRY_COMPARE(nameSpy.count(), 1);
             }
             void tst_QXYSeries::seriesVisible()
             {
                 QSignalSpy visibleSpy(m_series, SIGNAL(visibleChanged()));
                 QCOMPARE(m_series->isVisible(), true);
                 m_series->setVisible(false);
                 QCOMPARE(m_series->isVisible(), false);
                 m_series->setVisible(true);
                 TRY_COMPARE(visibleSpy.count(), 2);
             }
+            void tst_QXYSeries::seriesOpacity()
+            {
+                QSignalSpy opacitySpy(m_series, SIGNAL(opacityChanged()));
+                QCOMPARE(m_series->opacity(), 1.0);
+                m_series->setOpacity(0.5);
+                QCOMPARE(m_series->opacity(), 0.5);
+                QCOMPARE(opacitySpy.count(), 1);
+                m_series->setOpacity(0.0);
+                QCOMPARE(m_series->opacity(), 0.0);
+                QCOMPARE(opacitySpy.count(), 2);
+                m_series->setOpacity(1.0);
+                QCOMPARE(m_series->opacity(), 1.0);
+                QCOMPARE(opacitySpy.count(), 3);
+            }
             void tst_QXYSeries::append_data()
             {
                 QTest::addColumn< QList<QPointF> >("points");
                 QTest::newRow("0,0 1,1 2,2 3,3") << (QList<QPointF>() << QPointF(0,0) << QPointF(1,1) << QPointF(2,2) << QPointF(3,3));
                 QTest::newRow("0,0 -1,-1 -2,-2 -3,-3") << (QList<QPointF>() << QPointF(0,0) << QPointF(-1,-1) << QPointF(-2,-2) << QPointF(-3,-3));
             }
             void tst_QXYSeries::append_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 QSignalSpy addedSpy(m_series, SIGNAL(pointAdded(int)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(addedSpy.count(), points.count());
                 QCOMPARE(m_series->points(), points);
             }
             void tst_QXYSeries::chart_append_data()
             {
                 append_data();
             }
             void tst_QXYSeries::chart_append()
             {
                 append_raw();
                 m_chart->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QXYSeries::append_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 append_raw();
             }
             void tst_QXYSeries::append_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 append_chart();
             }
             void tst_QXYSeries::count_data()
             {
                 QTest::addColumn<int>("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("10") << 5;
             }
             void tst_QXYSeries::count_raw_data()
             {
                 count_data();
             }
             void tst_QXYSeries::count_raw()
             {
                 QFETCH(int, count);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 for(int i=0 ; i< count; ++i)
                     m_series->append(i,i);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->count(), count);
             }
             void tst_QXYSeries::remove_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 foreach(const QPointF& point,points)
                     m_series->remove(point);
                 QCOMPARE(m_series->points().count(), 0);
                 TRY_COMPARE(spy0.count(), 0);
                 m_series->append(points);
                 QCOMPARE(m_series->points(), points);
                 //reverse order
                 for(int i = points.count()-1 ; i>=0; i--){
                     m_series->remove(points[i]);
                 }
                 QCOMPARE(m_series->points().count(), 0);
             }
             void tst_QXYSeries::remove_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 remove_raw();
             }
             void tst_QXYSeries::remove_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 remove_chart();
             }
             void tst_QXYSeries::clear_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 m_series->clear();
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points().count(), 0);
             }
             void tst_QXYSeries::clear_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 clear_raw();
             }
             void tst_QXYSeries::clear_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 clear_chart();
             }
             void tst_QXYSeries::replace_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy pointReplacedSpy(m_series, SIGNAL(pointReplaced(int)));
                 QSignalSpy pointsReplacedSpy(m_series, SIGNAL(pointsReplaced()));
                 m_series->append(points);
                 TRY_COMPARE(pointReplacedSpy.count(), 0);
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 foreach(const QPointF& point, points)
                    m_series->replace(point.x(),point.y(),point.x(),0);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 // Replace a point that does not exist
                 m_series->replace(-123, 999, 0, 0);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 QList<QPointF> newPoints = m_series->points();
                 QCOMPARE(newPoints.count(), points.count());
                 for(int i =0 ; i<points.count() ; ++i) {
                     QCOMPARE(points[i].x(), newPoints[i].x());
                     QCOMPARE(newPoints[i].y(), 0.0);
                 }
                 // Replace all points
                 QList<QPointF> allPoints;
                 for (int i = 0; i < 10; i++)
                     allPoints.append(QPointF(i, (qreal) rand() / (qreal) RAND_MAX));
                 m_series->replace(allPoints);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 1);
             }
             void tst_QXYSeries::replace_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 replace_raw();
             }
             void tst_QXYSeries::replace_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 replace_chart();
             }
             void tst_QXYSeries::insert_data()
             {
                 append_data();
             }
             void tst_QXYSeries::insert()
             {
                 QFETCH(QList<QPointF>, points);
                 m_series->append(points);
                 QSignalSpy addedSpy(m_series, SIGNAL(pointAdded(int)));
                 m_series->insert(0, QPointF(5, 5));
                 TRY_COMPARE(addedSpy.count(), 1);
                 QCOMPARE(m_series->points().count(), points.count() + 1);
                 m_series->insert(m_series->count(), QPointF(6, 6));
                 TRY_COMPARE(addedSpy.count(), 2);
                 QCOMPARE(m_series->points().count(), points.count() + 2);
             }
             void tst_QXYSeries::oper_data()
             {
                 append_data();
             }
             void tst_QXYSeries::oper()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 foreach(const QPointF& point,points)
                 {
                     *m_series<<point;
                 }
                 QCOMPARE(m_series->points(), points);
                 TRY_COMPARE(spy0.count(), 0);
             }
             void tst_QXYSeries::pen_data()
             {
                 QTest::addColumn<QPen>("pen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QXYSeries::pen()
             {
                 QFETCH(QPen, pen);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 m_series->setPen(pen);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->pen(), pen);
                 m_chart->addSeries(m_series);
                 if (pen != QPen())
                     QCOMPARE(m_series->pen(), pen);
                 m_chart->setTheme(QChart::ChartThemeDark);
                 // setting a theme will overwrite all customizations
                 if (pen != QPen())
                     QVERIFY(m_series->pen() != pen);
             }
             void tst_QXYSeries::pointsVisible_data()
             {
                 QTest::addColumn<bool>("pointsVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QXYSeries::pointsVisible_raw_data()
             {
                 pointsVisible_data();
             }
             void tst_QXYSeries::pointsVisible_raw()
             {
                 QFETCH(bool, pointsVisible);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 m_series->setPointsVisible(pointsVisible);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->pointsVisible(), pointsVisible);
             }
             void tst_QXYSeries::changedSignals()
             {
                 QSignalSpy visibleSpy(m_series, SIGNAL(visibleChanged()));
                 QSignalSpy nameSpy(m_series, SIGNAL(nameChanged()));
                 QSignalSpy colorSpy(m_series, SIGNAL(colorChanged(QColor)));
                 // Visibility
                 m_series->setVisible(false);
                 m_series->setVisible(false);
                 TRY_COMPARE(visibleSpy.count(), 1);
                 m_series->setVisible(true);
                 TRY_COMPARE(visibleSpy.count(), 2);
                 // Color
                 m_series->setColor(QColor("aliceblue"));
                 TRY_COMPARE(colorSpy.count(), 1);
                 // Pen and Brush
                 QPen p = m_series->pen();
                 p.setColor("aquamarine");
                 m_series->setPen(p);
                 QBrush b = m_series->brush();
                 b.setColor("beige");
                 m_series->setBrush(b);
                 TRY_COMPARE(colorSpy.count(), 2);
                 // Verify all the signals again, to make sure no extra signals were emitted
                 TRY_COMPARE(visibleSpy.count(), 2);
                 TRY_COMPARE(nameSpy.count(), 0);
                 TRY_COMPARE(colorSpy.count(), 2);
             }

tests/auto/qxyseries/tst_qxyseries.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 TST_QXYSERIES_H
             #define TST_QXYSERIES_H
             #include <QtTest/QtTest>
             #include <qxyseries.h>
             #include <qchartview.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QXYSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 virtual void initTestCase();
                 virtual void cleanupTestCase();
                 virtual void init();
                 virtual void cleanup();
             private slots:
                 void seriesName();
                 void seriesVisible();
+                void seriesOpacity();
                 void oper_data();
                 void oper();
                 void pen_data();
                 void pen();
                 void pointsVisible_raw_data();
                 void pointsVisible_raw();
                 void append_raw_data();
                 void append_raw();
                 void append_chart_data();
                 void append_chart();
                 void append_chart_animation_data();
                 void append_chart_animation();
                 void chart_append_data();
                 void chart_append();
                 void count_raw_data();
                 void count_raw();
                 void remove_raw_data();
                 void remove_raw();
                 void remove_chart_data();
                 void remove_chart();
                 void remove_chart_animation_data();
                 void remove_chart_animation();
                 void clear_raw_data();
                 void clear_raw();
                 void clear_chart_data();
                 void clear_chart();
                 void clear_chart_animation_data();
                 void clear_chart_animation();
                 void replace_raw_data();
                 void replace_raw();
                 void replace_chart_data();
                 void replace_chart();
                 void replace_chart_animation_data();
                 void replace_chart_animation();
                 void insert_data();
                 void insert();
                 void changedSignals();
             protected:
                 void append_data();
                 void count_data();
                 void pointsVisible_data();
             protected:
                 QChartView* m_view;
                 QChart* m_chart;
                 QXYSeries* m_series;
             };
             #endif

tests/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "area series"
                 anchors.fill: parent
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: areaSeries
                 AreaSeries {
                     id: areaSeries
                     name: "area 1"
                     upperSeries: LineSeries {
                         XYPoint { x: 0; y: 1 }
                         XYPoint { x: 1; y: 1 }
                         XYPoint { x: 2; y: 3 }
                         XYPoint { x: 3; y: 3 }
                         XYPoint { x: 4; y: 2 }
                         XYPoint { x: 5; y: 0 }
                         XYPoint { x: 6; y: 2 }
                         XYPoint { x: 7; y: 1 }
                         XYPoint { x: 8; y: 2 }
                         XYPoint { x: 9; y: 1 }
                         XYPoint { x: 10; y: 3 }
                         XYPoint { x: 11; y: 3 }
                     }
                     lowerSeries: LineSeries {
                         XYPoint { x: 0; y: 0 }
                         XYPoint { x: 1; y: 0 }
                         XYPoint { x: 2; y: 0 }
                         XYPoint { x: 3; y: 0 }
                         XYPoint { x: 4; y: 0 }
                         XYPoint { x: 5; y: 0 }
                         XYPoint { x: 6; y: 0 }
                         XYPoint { x: 7; y: 0 }
                         XYPoint { x: 8; y: 0 }
                         XYPoint { x: 9; y: 0 }
                         XYPoint { x: 10; y: 0 }
                         XYPoint { x: 11; y: 0 }
                     }
                     onNameChanged:              console.log(name + ".onNameChanged: " + name);
                     onVisibleChanged:           console.log(name + ".onVisibleChanged: " + visible);
+                    onOpacityChanged:           console.log(name + ".onOpacityChanged: " + opacity);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onSelected:                 console.log(name + ".onSelected");
                     onColorChanged:             console.log(name + ".onColorChanged: " + color);
                     onBorderColorChanged:       console.log(name + ".onBorderColorChanged: " + borderColor);
                     onBorderWidthChanged:       console.log(name + ".onBorderChanged: " + borderWidth);
             //        onCountChanged:             console.log(name + ".onCountChanged: " + count);
                 }
                 AreaSeries {
                     name: "area 2"
                     upperSeries: LineSeries {
                         XYPoint { x: 0; y: 0.5 }
                         XYPoint { x: 1; y: 1.5 }
                         XYPoint { x: 2; y: 0.3 }
                         XYPoint { x: 3; y: 1.5 }
                         XYPoint { x: 4; y: 0.1 }
                         XYPoint { x: 5; y: 0.3 }
                         XYPoint { x: 6; y: 1.2 }
                         XYPoint { x: 7; y: 1.3 }
                         XYPoint { x: 8; y: 0.2 }
                         XYPoint { x: 9; y: 0.1 }
                         XYPoint { x: 10; y: 3.2 }
                         XYPoint { x: 11; y: 4.6 }
                     }
                     onNameChanged:              console.log(name + ".onNameChanged: " + name);
                     onVisibleChanged:           console.log(name + ".onVisibleChanged: " + visible);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onSelected:                 console.log(name + ".onSelected");
                     onColorChanged:             console.log(name + ".onColorChanged: " + color);
                     onBorderColorChanged:       console.log(name + ".onBorderColorChanged: " + borderColor);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/AreaEditor.qml +8 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
+                    text: "opacity +"
+                    onClicked: series.opacity += 0.1;
+                }
+                Button {
+                    text: "opacity -"
+                    onClicked: series.opacity -= 0.1;
+                }
+                Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "borderWidth + (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth += 0.5;
                 }
                 Button {
                     text: series != undefined ? "borderWidth - (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth -= 0.5;
                 }
                 Button {
                     id: upperButton
                     text: "upper series"
                     unpressedColor: "#79bd8f"
                     onClicked: {
                         lineEditor.visible = true;
                         color = "#00a388";
                         lowerButton.color = "#79bd8f";
                         lineEditor.series = series.upperSeries;
                     }
                 }
                 Button {
                     id: lowerButton
                     text: "lower series"
                     unpressedColor: "#79bd8f"
                     onClicked: {
                         lineEditor.visible = true;
                         color = "#00a388";
                         upperButton.color = "#79bd8f";
                         lineEditor.series = series.lowerSeries;
                     }
                 }
                 LineEditor {
                     id: lineEditor
                     visible: false
                 }
                 onSeriesChanged: lineEditor.series = series.upperSeries;
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarChart.qml +7 -6

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 BarSeries {
                     id: mySeries
                     name: "bar"
                     axisX: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
-                    onNameChanged:              console.log("groupedBarSeries.onNameChanged: " + series.name);
+                    onNameChanged:              console.log("barSeries.onNameChanged: " + series.name);
-                    onVisibleChanged:           console.log("groupedBarSeries.onVisibleChanged: " + series.visible);
+                    onVisibleChanged:           console.log("barSeries.onVisibleChanged: " + series.visible);
-                    onClicked:                  console.log("groupedBarSeries.onClicked: " + barset + " " + index);
+                    onOpacityChanged:           console.log("barSeries.onOpacityChanged: " + opacity);
-                    onHovered:                  console.log("groupedBarSeries.onHovered: " + barset + " " + status);
+                    onClicked:                  console.log("barSeries.onClicked: " + barset + " " + index);
-                    onLabelsVisibleChanged:     console.log("groupedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onHovered:                  console.log("barSeries.onHovered: " + barset + " " + status);
-                    onCountChanged:             console.log("groupedBarSeries.onCountChanged: " + count);
+                    onLabelsVisibleChanged:     console.log("barSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onCountChanged:             console.log("barSeries.onCountChanged: " + count);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarEditor.qml +8 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Row {
                 anchors.fill: parent
                 spacing: 5
                 property variant series
                 // buttons for selecting the edited object: series, barset or label
                 Flow {
                     spacing: 5
                     flow: Flow.TopToBottom
                     Button {
                         id: seriesButton
                         text: "series"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = true;
                             setFlow.visible = false;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             sliceButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: setButton
                         text: "BarSet"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             setFlow.visible = true;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: labelButton
                         text: "label"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             setFlow.visible = false;
                             labelsFlow.visible = true;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             sliceButton.color = "#79bd8f";
                         }
                     }
                 }
                 // Buttons for editing series
                 Flow {
                     id: seriesFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "visible"
                         onClicked: series.visible = !series.visible;
                     }
                     Button {
+                        text: "opacity +"
+                        onClicked: series.opacity += 0.1;
+                    }
+                    Button {
+                        text: "opacity -"
+                        onClicked: series.opacity -= 0.1;
+                    }
+                    Button {
                         text: "bar width +"
                         onClicked: series.barWidth += 0.1;
                     }
                     Button {
                         text: "bar width -"
                         onClicked: series.barWidth -= 0.1;
                     }
                 }
                 // Buttons for editing sets
                 Flow {
                     id: setFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "append set"
                         onClicked: {
                             var count = series.count;
                             series.append("set" + count, [0, 0.1 * count, 0.2 * count, 0.3 * count, 0.4 * count, 0.5 * count, 0.6 * count]);
                         }
                     }
                     Button {
                         text: "insert set"
                         onClicked: {
                             var count = series.count;
                             series.insert(count - 1, "set" + count, [0, 0.1 * count, 0.2 * count, 0.3 * count, 0.4 * count, 0.5 * count, 0.6 * count]);
                         }
                     }
                     Button {
                         text: "remove set"
                         onClicked: series.remove(series.at(series.count - 1));
                     }
                     Button {
                         text: "clear sets"
                         onClicked: series.clear();
                     }
                     Button {
                         text: "set 1 append"
                         onClicked: series.at(0).append(series.at(0).count + 1);
                     }
                     Button {
                         text: "set 1 replace"
                         onClicked: series.at(0).replace(series.at(0).count - 1, series.at(0).at(series.at(0).count - 1) + 1.5);
                     }
                     Button {
                         text: "set 1 remove"
                         onClicked: series.at(0).remove(series.at(0).count - 1);
                     }
                     Button {
                         text: "set 1 color"
                         onClicked: series.at(0).color = main.nextColor();
                     }
                     Button {
                         text: "set 1 border color"
                         onClicked: series.at(0).borderColor = main.nextColor();
                     }
                     Button {
                         text: "set 1 borderWidth +"
                         onClicked: series.at(0).borderWidth += 0.5;
                     }
                     Button {
                         text: "set 1 borderWidth -"
                         onClicked: series.at(0).borderWidth -= 0.5;
                     }
                 }
                 Flow {
                     id: labelsFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "labels visible"
                         onClicked: series.labelsVisible = !series.labelsVisible;
                     }
                     Button {
                         text: "set 1 label color"
                         onClicked: series.at(0).labelColor = main.nextColor();
                     }
                     FontEditor {
                         id: fontEditor
                         fontDescription: "label"
                         function editedFont() {
                             return series.at(0).labelFont;
                         }
                     }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml +7 -6

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 HorizontalBarSeries {
                     id: mySeries
                     name: "bar"
                     axisY: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
-                    onNameChanged:              console.log("groupedBarSeries.onNameChanged: " + series.name);
+                    onNameChanged:              console.log("horizontalBarSeries.onNameChanged: " + series.name);
-                    onVisibleChanged:           console.log("groupedBarSeries.onVisibleChanged: " + series.visible);
+                    onVisibleChanged:           console.log("horizontalBarSeries.onVisibleChanged: " + series.visible);
-                    onClicked:                  console.log("groupedBarSeries.onClicked: " + barset + " " + index);
+                    onOpacityChanged:           console.log("horizontalBarSeries.onOpacityChanged: " + opacity);
-                    onHovered:                  console.log("groupedBarSeries.onHovered: " + barset + " " + status);
+                    onClicked:                  console.log("horizontalBarSeries.onClicked: " + barset + " " + index);
-                    onLabelsVisibleChanged:     console.log("groupedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onHovered:                  console.log("horizontalBarSeries.onHovered: " + barset + " " + status);
-                    onCountChanged:             console.log("groupedBarSeries.onCountChanged: " + count);
+                    onLabelsVisibleChanged:     console.log("horizontalBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onCountChanged:             console.log("horizontalBarSeries.onCountChanged: " + count);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml +7 -6

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Percent bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 HorizontalPercentBarSeries {
                     id: mySeries
                     name: "bar"
                     axisY: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
-                    onNameChanged:              console.log("percentBarSeries.onNameChanged: " + series.name);
+                    onNameChanged:              console.log("horizontalPercentBarSeries.onNameChanged: " + series.name);
-                    onVisibleChanged:           console.log("percentBarSeries.onVisibleChanged: " + series.visible);
+                    onVisibleChanged:           console.log("horizontalPercentBarSeries.onVisibleChanged: " + series.visible);
-                    onClicked:                  console.log("percentBarSeries.onClicked: " + barset + " " + index);
+                    onOpacityChanged:           console.log("horizontalPercentBarSeries.onOpacityChanged: " + opacity);
-                    onHovered:                  console.log("percentBarSeries.onHovered: " + barset + " " + status);
+                    onClicked:                  console.log("horizontalPercentBarSeries.onClicked: " + barset + " " + index);
-                    onLabelsVisibleChanged:     console.log("percentBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onHovered:                  console.log("horizontalPercentBarSeries.onHovered: " + barset + " " + status);
-                    onCountChanged:             console.log("percentBarSeries.onCountChanged: " + count);
+                    onLabelsVisibleChanged:     console.log("horizontalPercentBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onCountChanged:             console.log("horizontalPercentBarSeries.onCountChanged: " + count);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml +7 -6

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Stacked bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 HorizontalStackedBarSeries {
                     id: mySeries
                     name: "bar"
                     axisY: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
-                    onNameChanged:              console.log("stackedBarSeries.onNameChanged: " + series.name);
+                    onNameChanged:              console.log("horizontalStackedBarSeries.onNameChanged: " + series.name);
-                    onVisibleChanged:           console.log("stackedBarSeries.onVisibleChanged: " + series.visible);
+                    onVisibleChanged:           console.log("horizontalStackedBarSeries.onVisibleChanged: " + series.visible);
-                    onClicked:                  console.log("stackedBarSeries.onClicked: " + barset + " " + index);
+                    onOpacityChanged:           console.log("horizontalStackedBarSeries.onOpacityChanged: " + opacity);
-                    onHovered:                  console.log("stackedBarSeries.onHovered: " + barset + " " + status);
+                    onClicked:                  console.log("horizontalStackedBarSeries.onClicked: " + barset + " " + index);
-                    onLabelsVisibleChanged:     console.log("stackedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onHovered:                  console.log("horizontalStackedBarSeries.onHovered: " + barset + " " + status);
-                    onCountChanged:             console.log("stackedBarSeries.onCountChanged: " + count);
+                    onLabelsVisibleChanged:     console.log("horizontalStackedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
+                    onCountChanged:             console.log("horizontalStackedBarSeries.onCountChanged: " + count);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/LineChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 property variant series: lineSeries
                 title: "line series"
                 anchors.fill: parent
                 animationOptions: ChartView.SeriesAnimations
                 LineSeries {
                     id: lineSeries
                     name: "line 1"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     XYPoint { x: 1.9; y: 3.3 }
                     XYPoint { x: 2.1; y: 2.1 }
                     XYPoint { x: 2.9; y: 4.9 }
                     XYPoint { x: 3.4; y: 3.0 }
                     XYPoint { x: 4.1; y: 3.3 }
                     onNameChanged:              console.log("lineSeries.onNameChanged: " + name);
                     onVisibleChanged:           console.log("lineSeries.onVisibleChanged: " + visible);
+                    onOpacityChanged:           console.log(name + ".onOpacityChanged: " + opacity);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onPointReplaced:            console.log("lineSeries.onPointReplaced: " + index);
                     onPointRemoved:             console.log("lineSeries.onPointRemoved: " + index);
                     onPointAdded:               console.log("lineSeries.onPointAdded: " + series.at(index).x + ", " + series.at(index).y);
                     onColorChanged:             console.log("lineSeries.onColorChanged: " + color);
                     onWidthChanged:             console.log("lineSeries.onWidthChanged: " + width);
                     onStyleChanged:             console.log("lineSeries.onStyleChanged: " + style);
                     onCapStyleChanged:          console.log("lineSeries.onCapStyleChanged: " + capStyle);
                     onCountChanged:             console.log("lineSeries.onCountChanged: " + count);
                 }
                 LineSeries {
                     name: "line 2"
                     XYPoint { x: 1.1; y: 1.1 }
                     XYPoint { x: 1.9; y: 2.3 }
                     XYPoint { x: 2.1; y: 1.1 }
                     XYPoint { x: 2.9; y: 3.9 }
                     XYPoint { x: 3.4; y: 2.0 }
                     XYPoint { x: 4.1; y: 2.3 }
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/LineEditor.qml +8 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
+                    text: "opacity +"
+                    onClicked: series.opacity += 0.1;
+                }
+                Button {
+                    text: "opacity -"
+                    onClicked: series.opacity -= 0.1;
+                }
+                Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "width + (" + series.width + ")" : ""
                     onClicked: series.width += 0.5;
                 }
                 Button {
                     text: series != undefined ? "width - (" + series.width + ")" : ""
                     onClicked: series.width -= 0.5;
                 }
                 Button {
                     text: series != undefined ? "style + (" + series.style + ")" : ""
                     onClicked: series.style++;
                 }
                 Button {
                     text: series != undefined ? "style - (" + series.style + ")" : ""
                     onClicked: series.style--;
                 }
                 Button {
                     text: series != undefined ? "cap style + (" + series.capStyle + ")" : ""
                     onClicked: series.capStyle++;
                 }
                 Button {
                     text: series != undefined ? "cap style - (" +series.capStyle + ")" : ""
                     onClicked: series.capStyle--;
                 }
                 Button {
                     text: "points visible"
                     onClicked: series.pointsVisible = !series.pointsVisible;
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
                         series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
                     onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Percent bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 PercentBarSeries {
                     id: mySeries
                     name: "bar"
                     axisX: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     onNameChanged:              console.log("percentBarSeries.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("percentBarSeries.onVisibleChanged: " + series.visible);
+                    onOpacityChanged:           console.log("percentBarSeries.onOpacityChanged: " + opacity);
                     onClicked:                  console.log("percentBarSeries.onClicked: " + barset + " " + index);
                     onHovered:                  console.log("percentBarSeries.onHovered: " + barset + " " + status);
                     onLabelsVisibleChanged:     console.log("percentBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
                     onCountChanged:             console.log("percentBarSeries.onCountChanged: " + count);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PieChart.qml +4 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 id: chart
                 title: "pie series"
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: pieSeries
                 PieSeries {
                     id: pieSeries
                     name: "pie"
                     PieSlice { label: "slice1"; value: 11;
                         onValueChanged:         console.log("slice.onValueChanged: " + value);
                         onLabelVisibleChanged:  console.log("slice.onLabelVisibleChanged: " + labelVisible);
                         onPenChanged:           console.log("slice.onPenChanged: " + pen);
                         onBorderColorChanged:   console.log("slice.onBorderColorChanged: " + borderColor);
                         onBorderWidthChanged:   console.log("slice.onBorderWidthChanged: " + borderWidth);
                         onBrushChanged:         console.log("slice.onBrushChanged: " + brush);
                         onColorChanged:         console.log("slice.onColorChanged: " + color);
                         onLabelColorChanged:    console.log("slice.onLabelColorChanged: " + labelColor);
                         onLabelBrushChanged:    console.log("slice.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:     console.log("slice.onLabelFontChanged: " + labelFont);
                         onPercentageChanged:    console.log("slice.onPercentageChanged: " + percentage);
                         onStartAngleChanged:    console.log("slice.onStartAngleChanged: " + startAngle);
                         onAngleSpanChanged:     console.log("slice.onAngleSpanChanged: " + angleSpan);
                         onClicked:              console.log("slice.onClicked: " + label);
                         onHovered:              console.log("slice.onHovered: " + state);
                     }
                     PieSlice { label: "slice2"; value: 22 }
                     PieSlice { label: "slice3"; value: 33 }
                     PieSlice { label: "slice4"; value: 44 }
-                    onNameChanged:              console.log("pieSeries.onNameChanged: " + series.name);
+                    onNameChanged:              console.log("pieSeries.onNameChanged: " + name);
                     onVisibleChanged:           console.log("pieSeries.onVisibleChanged: " + series.visible);
+                    onOpacityChanged:           console.log("pieSeries.onOpacityChanged: " + opacity);
                     onClicked:                  console.log("pieSeries.onClicked: " + slice.label);
                     onHovered:                  console.log("pieSeries.onHovered: " + slice.label);
                     onAdded:                    console.log("pieSeries.onAdded: " + slices);
                     onSliceAdded:               console.log("pieSeries.onSliceAdded: " + slice.label);
                     onRemoved:                  console.log("pieSeries.onRemoved: " + slices);
                     onSliceRemoved:             console.log("pieSeries.onSliceRemoved: " + slice.label);
-                    onCountChanged:             console.log("pieSeries.onCountChanged: " + series.count);
+                    onCountChanged:             console.log("pieSeries.onCountChanged: " + count);
-                    onSumChanged:               console.log("pieSeries.onSumChanged: " + series.sum);
+                    onSumChanged:               console.log("pieSeries.onSumChanged: " + sum);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PieEditor.qml +8 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             Row {
                 anchors.fill: parent
                 spacing: 5
                 property variant series
                 property int sliceIndex: 0
                 // buttons for selecting the edited object: series, slice or label
                 Flow {
                     spacing: 5
                     flow: Flow.TopToBottom
                     Button {
                         id: seriesButton
                         text: "series"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = true;
                             slicesFlow.visible = false;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             sliceButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: sliceButton
                         text: "slice"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             slicesFlow.visible = true;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: labelButton
                         text: "label"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             slicesFlow.visible = false;
                             labelsFlow.visible = true;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             sliceButton.color = "#79bd8f";
                         }
                     }
                 }
                 // Buttons for editing series
                 Flow {
                     id: seriesFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "visible"
                         onClicked: series.visible = !series.visible;
                     }
                     Button {
+                        text: "series opacity +"
+                        onClicked: series.opacity += 0.1;
+                    }
+                    Button {
+                        text: "series opacity -"
+                        onClicked: series.opacity -= 0.1;
+                    }
+                    Button {
                         text: "series hpos +"
                         onClicked: series.horizontalPosition += 0.1;
                     }
                     Button {
                         text: "series hpos -"
                         onClicked: series.horizontalPosition -= 0.1;
                     }
                     Button {
                         text: "series vpos +"
                         onClicked: series.verticalPosition += 0.1;
                     }
                     Button {
                         text: "series vpos -"
                         onClicked: series.verticalPosition -= 0.1;
                     }
                     Button {
                         text: "series size +"
                         onClicked: series.size += 0.1;
                     }
                     Button {
                         text: "series size -"
                         onClicked: series.size -= 0.1;
                     }
                     Button {
                         text: "series start angle +"
                         onClicked: series.startAngle += 1.1;
                     }
                     Button {
                         text: "series start angle -"
                         onClicked: series.startAngle -= 1.1;
                     }
                     Button {
                         text: "series end angle +"
                         onClicked: series.endAngle += 1.1;
                     }
                     Button {
                         text: "series end angle -"
                         onClicked: series.endAngle -= 1.1;
                     }
                 }
                 // Buttons for editing slices
                 Flow {
                     id: slicesFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "append slice"
                         onClicked: series.append("slice" + (series.count + 1), 3.0);
                     }
                     Button {
                         text: "remove slice"
                         onClicked: series.remove(series.at(series.count - 1));
                     }
                     Button {
                         text: "slice color"
                         onClicked: series.at(sliceIndex).color = main.nextColor();
                     }
                     Button {
                         text: "slice border color"
                         onClicked: series.at(sliceIndex).borderColor = main.nextColor();
                     }
                     Button {
                         text: "slice border width +"
                         onClicked: series.at(sliceIndex).borderWidth++;
                     }
                     Button {
                         text: "slice border width -"
                         onClicked: series.at(sliceIndex).borderWidth--;
                     }
                     Button {
                         text: "slice exploded"
                         onClicked: series.at(sliceIndex).exploded = !series.at(sliceIndex).exploded;
                     }
                     Button {
                         text: "slice explode dist +"
                         onClicked: series.at(sliceIndex).explodeDistanceFactor += 0.1;
                     }
                     Button {
                         text: "slice explode dist -"
                         onClicked: series.at(sliceIndex).explodeDistanceFactor -= 0.1;
                     }
                 }
                 // Buttons for editing labels
                 Flow {
                     id: labelsFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "label visible"
                         onClicked: series.at(sliceIndex).labelVisible = !series.at(sliceIndex).labelVisible;
                     }
                     Button {
                         text: "LabelInsideNormal"
                         onClicked: series.at(sliceIndex).labelPosition = PieSlice.LabelInsideNormal;
                     }
                     Button {
                         text: "LabelInsideHorizontal"
                         onClicked: series.at(sliceIndex).labelPosition = PieSlice.LabelInsideHorizontal;
                     }
                     Button {
                         text: "LabelInsideTangential"
                         onClicked: series.at(sliceIndex).labelPosition = PieSlice.LabelInsideTangential;
                     }
                     Button {
                         text: "LabelOutside"
                         onClicked: series.at(sliceIndex).labelPosition = PieSlice.LabelOutside;
                     }
                     Button {
                         text: "label arm len +"
                         onClicked: series.at(sliceIndex).labelArmLengthFactor += 0.1;
                     }
                     Button {
                         text: "label arm len -"
                         onClicked: series.at(sliceIndex).labelArmLengthFactor -= 0.1;
                     }
                     Button {
                         text: "slice label color"
                         onClicked: series.at(sliceIndex).labelColor = main.nextColor();
                     }
                     FontEditor {
                         id: fontEditor
                         fontDescription: "label"
                         function editedFont() {
                             return series.at(sliceIndex).labelFont;
                         }
                     }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "scatter series"
                 property variant series: scatterSeries
                 animationOptions: ChartView.SeriesAnimations
                 ScatterSeries {
                     id: scatterSeries
                     name: "scatter 1"
                     XYPoint { x: 1.5; y: 1.5 }
                     XYPoint { x: 1.5; y: 1.6 }
                     XYPoint { x: 1.57; y: 1.55 }
                     XYPoint { x: 1.8; y: 1.8 }
                     XYPoint { x: 1.9; y: 1.6 }
                     XYPoint { x: 2.1; y: 1.3 }
                     XYPoint { x: 2.5; y: 2.1 }
                     onNameChanged:              console.log("scatterSeries.onNameChanged: " + name);
                     onVisibleChanged:           console.log("scatterSeries.onVisibleChanged: " + visible);
+                    onOpacityChanged:           console.log(name + ".onOpacityChanged: " + opacity);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onPointReplaced:            console.log("scatterSeries.onPointReplaced: " + index);
                     onPointRemoved:             console.log("scatterSeries.onPointRemoved: " + index);
                     onPointAdded:               console.log("scatterSeries.onPointAdded: " + series.at(index).x + ", " + series.at(index).y);
                     onColorChanged:             console.log("scatterSeries.onColorChanged: " + color);
                     onBorderColorChanged:       console.log("scatterSeries.onBorderColorChanged: " + borderColor);
                     onBorderWidthChanged:       console.log("scatterSeries.onBorderChanged: " + borderWidth);
                     onCountChanged:             console.log("scatterSeries.onCountChanged: " + count);
                 }
                 ScatterSeries {
                     name: "scatter2"
                     XYPoint { x: 2.0; y: 2.0 }
                     XYPoint { x: 2.0; y: 2.1 }
                     XYPoint { x: 2.07; y: 2.05 }
                     XYPoint { x: 2.2; y: 2.9 }
                     XYPoint { x: 2.4; y: 2.7 }
                     XYPoint { x: 2.67; y: 2.65 }
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ScatterEditor.qml +8 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
+                    text: "opacity +"
+                    onClicked: series.opacity += 0.1;
+                }
+                Button {
+                    text: "opacity -"
+                    onClicked: series.opacity -= 0.1;
+                }
+                Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "borderWidth + (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth += 0.5;
                 }
                 Button {
                     text: series != undefined ? "borderWidth - (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth -= 0.5;
                 }
                 Button {
                     text: "markerSize +"
                     onClicked: series.markerSize += 1.0;
                 }
                 Button {
                     text: "markerSize -"
                     onClicked: series.markerSize -= 1.0;
                 }
                 Button {
                     text: "markerShape"
                     onClicked: series.markerShape = ((series.markerShape + 1) % 2);
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
                         series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
                     onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "spline series"
                 anchors.fill: parent
                 property variant series: splineSeries
                 animationOptions: ChartView.SeriesAnimations
                 SplineSeries {
                     id: splineSeries
                     name: "spline 1"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     XYPoint { x: 1.9; y: 3.3 }
                     XYPoint { x: 2.1; y: 2.1 }
                     XYPoint { x: 2.9; y: 4.9 }
                     XYPoint { x: 3.4; y: 3.0 }
                     XYPoint { x: 4.1; y: 3.3 }
                     onNameChanged:              console.log("splineSeries.onNameChanged: " + name);
                     onVisibleChanged:           console.log("splineSeries.onVisibleChanged: " + visible);
+                    onOpacityChanged:           console.log(name + ".onOpacityChanged: " + opacity);
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                     onPointReplaced:            console.log("splineSeries.onPointReplaced: " + index);
                     onPointRemoved:             console.log("splineSeries.onPointRemoved: " + index);
                     onPointAdded:               console.log("splineSeries.onPointAdded: " + series.at(index).x + ", " + series.at(index).y);
                     onColorChanged:             console.log("splineSeries.onColorChanged: " + color);
                     onWidthChanged:             console.log("splineSeries.onWidthChanged: " + width);
                     onStyleChanged:             console.log("splineSeries.onStyleChanged: " + style);
                     onCapStyleChanged:          console.log("splineSeries.onCapStyleChanged: " + capStyle);
                     onCountChanged:             console.log("splineSeries.onCountChanged: " + count);
                 }
                 SplineSeries {
                     name: "spline 2"
                     XYPoint { x: 1.1; y: 1.1 }
                     XYPoint { x: 1.9; y: 2.3 }
                     XYPoint { x: 2.1; y: 1.1 }
                     XYPoint { x: 2.9; y: 3.9 }
                     XYPoint { x: 3.4; y: 2.0 }
                     XYPoint { x: 4.1; y: 2.3 }
                     onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Stacked bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: mySeries
                 StackedBarSeries {
                     id: mySeries
                     name: "bar"
                     axisX: BarCategoryAxis { categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     onNameChanged:              console.log("stackedBarSeries.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("stackedBarSeries.onVisibleChanged: " + series.visible);
+                    onOpacityChanged:           console.log("stackedBarSeries.onOpacityChanged: " + opacity);
                     onClicked:                  console.log("stackedBarSeries.onClicked: " + barset + " " + index);
                     onHovered:                  console.log("stackedBarSeries.onHovered: " + barset + " " + status);
                     onLabelsVisibleChanged:     console.log("stackedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
                     onCountChanged:             console.log("stackedBarSeries.onCountChanged: " + count);
                 }
             }

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