HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1465:7735835ca38c

Property notifications: axis minmax, bar properties, xyseries p-visibl and count

Tero Ahola -

r1465:7735835ca38c

parent child

Context file:

r1465:7735835ca38c

Collapse all files

plugins/declarative/declarativebarseries.cpp +9 -36

             /****************************************************************************
             **
             ** 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 "declarativebarseries.h"
             #include "declarativechart.h"
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QHBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeBarSet::DeclarativeBarSet(QObject *parent) :
                 QBarSet("", parent)
             {
+                connect(this, SIGNAL(valuesAdded(int,int)), this, SLOT(handleCountChanged(int, int)));
+                connect(this, SIGNAL(valuesRemoved(int,int)), this, SLOT(handleCountChanged(int, int)));
+            }
+            void DeclarativeBarSet::handleCountChanged(int index, int count)
+            {
+                Q_UNUSED(index)
+                Q_UNUSED(count)
+                emit countChanged(QBarSet::count());
             }
             QVariantList DeclarativeBarSet::values()
             {
                 QVariantList values;
                 for (int i(0); i < count(); i++)
                     values.append(QVariant(at(i)));
                 return values;
             }
             void DeclarativeBarSet::setValues(QVariantList values)
             {
                 while (count())
                     remove(count() - 1);
                 for (int i(0); i < values.count(); i++) {
                     if (values.at(i).canConvert(QVariant::Double))
                         append(values[i].toDouble());
                 }
             }
-            QColor DeclarativeBarSet::color()
-                return brush().color();
-            void DeclarativeBarSet::setColor(QColor color)
-                QBrush b = brush();
-                b.setColor(color);
-                setBrush(b);
-            QColor DeclarativeBarSet::borderColor()
-                return pen().color();
-            void DeclarativeBarSet::setBorderColor(QColor color)
-                QPen p = pen();
-                p.setColor(color);
-                setPen(p);
-            QColor DeclarativeBarSet::labelColor()
-                return labelBrush().color();
-            void DeclarativeBarSet::setLabelColor(QColor color)
-                QBrush b = labelBrush();
-                b.setColor(color);
-                setLabelBrush(b);
             DeclarativeBarSeries::DeclarativeBarSeries(QDeclarativeItem *parent) :
                 QBarSeries(parent)
             {
             }
             void DeclarativeBarSeries::classBegin()
             {
             }
             void DeclarativeBarSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeGroupedBarSeries::DeclarativeGroupedBarSeries(QDeclarativeItem *parent) :
                 QGroupedBarSeries(parent)
             {
             }
             void DeclarativeGroupedBarSeries::classBegin()
             {
             }
             void DeclarativeGroupedBarSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeGroupedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeGroupedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeGroupedBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeStackedBarSeries::DeclarativeStackedBarSeries(QDeclarativeItem *parent) :
                 QStackedBarSeries(parent)
             {
             }
             void DeclarativeStackedBarSeries::classBegin()
             {
             }
             void DeclarativeStackedBarSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeStackedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeStackedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeStackedBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativePercentBarSeries::DeclarativePercentBarSeries(QDeclarativeItem *parent) :
                 QPercentBarSeries(parent)
             {
             }
             void DeclarativePercentBarSeries::classBegin()
             {
             }
             void DeclarativePercentBarSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativePercentBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativePercentBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativePercentBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             #include "moc_declarativebarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativebarseries.h +7 -9

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEBARSERIES_H
             #define DECLARATIVEBARSERIES_H
             #include "qchartglobal.h"
             #include <QGroupedBarSeries>
             #include <QStackedBarSeries>
             #include <QPercentBarSeries>
             #include <QBarSet>
             #include <QDeclarativeItem>
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class DeclarativeBarSet : public QBarSet
             {
                 Q_OBJECT
                 Q_PROPERTY(QVariantList values READ values WRITE setValues)
-                Q_PROPERTY(QColor color READ color WRITE setColor)
+                Q_PROPERTY(int count READ count NOTIFY countChanged)
-                Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor)
-                Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor)
             public:
                 explicit DeclarativeBarSet(QObject *parent = 0);
                 QVariantList values();
                 void setValues(QVariantList values);
-                QColor color();
-                void setColor(QColor color);
-                QColor borderColor();
-                void setBorderColor(QColor color);
-                QColor labelColor();
-                void setLabelColor(QColor color);
             public: // From QBarSet
                 Q_INVOKABLE void append(qreal value) { QBarSet::append(value); }
                 Q_INVOKABLE void append(qreal x, qreal y) { QBarSet::append(QPointF(x, y)); }
+            Q_SIGNALS:
+                void countChanged(int count);
+            private Q_SLOTS:
+                void handleCountChanged(int index, int count);
             };
             class DeclarativeBarSeries : public QBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeBarSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<QObject> seriesChildren();
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             class DeclarativeGroupedBarSeries : public QGroupedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeGroupedBarSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<QObject> seriesChildren();
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             class DeclarativeStackedBarSeries : public QStackedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeStackedBarSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<QObject> seriesChildren();
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             class DeclarativePercentBarSeries : public QPercentBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativePercentBarSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<QObject> seriesChildren();
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEBARSERIES_H

plugins/declarative/declarativelineseries.cpp +11 -4

             /****************************************************************************
             **
             ** 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 "declarativelineseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeLineSeries::DeclarativeLineSeries(QObject *parent) :
                 QLineSeries(parent)
             {
+                connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
+                connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeLineSeries::xySeries()
             {
                 return this;
             }
+            void DeclarativeLineSeries::handleCountChanged(int index)
+            {
+                Q_UNUSED(index)
+                emit countChanged(points().count());
+            }
             QDeclarativeListProperty<QObject> DeclarativeLineSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeLineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
-                QXYSeries *series = qobject_cast<QXYSeries*>(list->object);
+                Q_UNUSED(list)
-                DeclarativeXyPoint *point = qobject_cast<DeclarativeXyPoint *>(element);
+                Q_UNUSED(element)
-                if (series && point)
+                // Empty implementation, childs are parsed in componentComplete
-                    series->append(*point);
             }
             #include "moc_declarativelineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativelineseries.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 DECLARATIVELINESERIES_H
             #define DECLARATIVELINESERIES_H
             #include "qchartglobal.h"
             #include "qlineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             #include <QDeclarativeListProperty>
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeLineSeries : public QLineSeries, public DeclarativeXySeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QColor color READ penColor WRITE setPenColor)
+                Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeLineSeries(QObject *parent = 0);
                 QXYSeries *xySeries();
                 QDeclarativeListProperty<QObject> declarativeChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public: // from QLineSeries
                 Q_INVOKABLE void append(qreal x, qreal y) { QLineSeries::append(x, y); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { QLineSeries::remove(x, y); }
                 Q_INVOKABLE void clear() { QLineSeries::clear(); }
                 Q_INVOKABLE DeclarativeXyPoint *at(int index) { return DeclarativeXySeries::at(index); }
+            Q_SIGNALS:
+                void countChanged(int count);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
+                void handleCountChanged(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVELINESERIES_H

plugins/declarative/declarativescatterseries.cpp +11 -4

             /****************************************************************************
             **
             ** 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 "declarativescatterseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeScatterSeries::DeclarativeScatterSeries(QObject *parent) :
                 QScatterSeries(parent)
             {
+                connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
+                connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeScatterSeries::xySeries()
             {
                 return this;
             }
+            void DeclarativeScatterSeries::handleCountChanged(int index)
+            {
+                Q_UNUSED(index)
+                emit countChanged(QScatterSeries::count());
+            }
             QDeclarativeListProperty<QObject> DeclarativeScatterSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeScatterSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
-                QXYSeries *series = qobject_cast<QXYSeries*>(list->object);
+                Q_UNUSED(list)
-                DeclarativeXyPoint *point = qobject_cast<DeclarativeXyPoint *>(element);
+                Q_UNUSED(element)
-                if (series && point)
+                // Empty implementation, childs are parsed in componentComplete
-                    series->append(*point);
             }
             QColor DeclarativeScatterSeries::brushColor()
             {
                 return brush().color();
             }
             void DeclarativeScatterSeries::setBrushColor(QColor color)
             {
                 QBrush b = brush();
                 b.setColor(color);
                 setBrush(b);
             }
             #include "moc_declarativescatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativescatterseries.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 DECLARATIVESCATTERSERIES_H
             #define DECLARATIVESCATTERSERIES_H
             #include "qchartglobal.h"
             #include "qscatterseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeListProperty>
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeScatterSeries : public QScatterSeries, public DeclarativeXySeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QColor color READ brushColor WRITE setBrushColor)
                 Q_PROPERTY(QColor borderColor READ penColor WRITE setPenColor)
+                Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeScatterSeries(QObject *parent = 0);
                 QXYSeries *xySeries();
                 QDeclarativeListProperty<QObject> declarativeChildren();
                 QColor brushColor();
                 void setBrushColor(QColor color);
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public: // from QScatterSeries
                 Q_INVOKABLE void append(qreal x, qreal y) { QScatterSeries::append(x, y); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { QScatterSeries::remove(x, y); }
                 Q_INVOKABLE void clear() { QScatterSeries::clear(); }
                 Q_INVOKABLE DeclarativeXyPoint *at(int index) { return DeclarativeXySeries::at(index); }
+            Q_SIGNALS:
+                void countChanged(int count);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
+                void handleCountChanged(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESCATTERSERIES_H

plugins/declarative/declarativesplineseries.cpp +11 -4

             /****************************************************************************
             **
             ** 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 "declarativesplineseries.h"
             #include "declarativechart.h"
             #include <QChart>
             #include "declarativexypoint.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeSplineSeries::DeclarativeSplineSeries(QObject *parent) :
                 QSplineSeries(parent)
             {
+                connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
+                connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeSplineSeries::xySeries()
             {
                 return this;
             }
+            void DeclarativeSplineSeries::handleCountChanged(int index)
+            {
+                Q_UNUSED(index)
+                emit countChanged(points().count());
+            }
             QDeclarativeListProperty<QObject> DeclarativeSplineSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeSplineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
-                QXYSeries *series = qobject_cast<QXYSeries*>(list->object);
+                Q_UNUSED(list)
-                DeclarativeXyPoint *point = qobject_cast<DeclarativeXyPoint *>(element);
+                Q_UNUSED(element)
-                if (series && point)
+                // Empty implementation, childs are parsed in componentComplete
-                    series->append(*point);
             }
             #include "moc_declarativesplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativesplineseries.h +4 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 DECLARATIVESPLINESERIES_H
             #define DECLARATIVESPLINESERIES_H
             #include "qchartglobal.h"
             #include "qsplineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             #include <QDeclarativeListProperty>
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeSplineSeries : public QSplineSeries, public DeclarativeXySeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QColor color READ penColor WRITE setPenColor)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeSplineSeries(QObject *parent = 0);
                 QXYSeries *xySeries();
                 QDeclarativeListProperty<QObject> declarativeChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public: // from QSplineSeries
                 Q_INVOKABLE void append(qreal x, qreal y) { QSplineSeries::append(x, y); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { QSplineSeries::remove(x, y); }
                 Q_INVOKABLE void clear() { QSplineSeries::clear(); }
                 Q_INVOKABLE DeclarativeXyPoint *at(int index) { return DeclarativeXySeries::at(index); }
+            Q_SIGNALS:
+                void countChanged(int count);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
+                void handleCountChanged(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESPLINESERIES_H

plugins/declarative/declarativexyseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //#include "DeclarativeXySeries.h"
             #include "declarativexyseries.h"
             #include "declarativechart.h"
             #include <QXYSeries>
             #include <QVXYModelMapper>
             #include <QHXYModelMapper>
             #include <QDeclarativeListProperty>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeXySeries::DeclarativeXySeries()
             {
             }
             DeclarativeXySeries::~DeclarativeXySeries()
             {
             }
             void DeclarativeXySeries::classBegin()
             {
             }
             void DeclarativeXySeries::componentComplete()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 foreach(QObject *child, series->children()) {
                     if (qobject_cast<DeclarativeXyPoint *>(child)) {
-                        // TODO:
+                        DeclarativeXyPoint *point = qobject_cast<DeclarativeXyPoint *>(child);
-            //            series->append(qobject_cast<DeclarativeXyPoint *>(child));
+                        series->append(point->x(), point->y());
                     } else if(qobject_cast<QVXYModelMapper *>(child)) {
                         QVXYModelMapper *mapper = qobject_cast<QVXYModelMapper *>(child);
                         mapper->setSeries(series);
                     } else if(qobject_cast<QHXYModelMapper *>(child)) {
                         QHXYModelMapper *mapper = qobject_cast<QHXYModelMapper *>(child);
                         mapper->setSeries(series);
                     }
                 }
             }
             QColor DeclarativeXySeries::penColor()
             {
                 // All the inherited objects must be of type QXYSeries, so it is safe to cast
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 return series->pen().color();
             }
             void DeclarativeXySeries::setPenColor(QColor color)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 QPen pen = series->pen();
                 pen.setColor(color);
                 series->setPen(pen);
             }
             DeclarativeXyPoint *DeclarativeXySeries::at(int index)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 if (index < series->count()) {
                     QPointF point = series->points().at(index);
                     DeclarativeXyPoint *xyPoint = new DeclarativeXyPoint(series);
                     xyPoint->setX(point.x());
                     xyPoint->setY(point.y());
                     return xyPoint;
                 }
                 return 0;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

src/axis/qaxis.h +4 -4

             /****************************************************************************
             **
             ** 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 QAXIS_H
             #define QAXIS_H
             #include <qchartglobal.h>
             #include <qaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAxis : public QObject
             {
             	Q_OBJECT
                 Q_PROPERTY(bool visible READ isAxisVisible WRITE setAxisVisible NOTIFY visibleChanged)
                 Q_PROPERTY(QColor color READ axisPenColor WRITE setAxisPenColor NOTIFY colorChanged)
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
-                Q_PROPERTY(qreal min READ min WRITE setMin)
+                Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
-                Q_PROPERTY(qreal max READ max WRITE setMax)
+                Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
                 Q_PROPERTY(int ticksCount READ ticksCount WRITE setTicksCount NOTIFY ticksCountChanged)
                 Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled NOTIFY niceNumbersEnabledChanged)
             public:
                 QAxis(QObject *parent =0);
                 ~QAxis();
                 //axis handling
                 bool isAxisVisible() const;
                 void setAxisVisible(bool visible = true);
                 void setAxisPen(const QPen &pen);
                 QPen axisPen() const;
                 void setAxisPenColor(QColor color);
                 QColor axisPenColor() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const;
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
                 QAxisCategories* categories();
                 void show();
                 void hide();
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void gridVisibleChanged(bool visible);
-            	void minChanged(qreal min);
-            	void maxChanged(qreal max);
             	void rangeChanged(qreal min, qreal max);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void labelsAngleChanged(int angle);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
+                void minChanged(qreal min);
+                void maxChanged(qreal max);
                 void ticksCountChanged(int count);
                 void niceNumbersEnabledChanged(bool enabled);
             private:
             	QScopedPointer<QAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAxis)
                 friend class ChartDataSet;
                 friend class ChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/barchart/qbarseries.cpp +4 -17

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \property QBarSeries::barWidth
-                \brief Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
+                \brief The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar. This is
                 because with grouped series it is more logical to set width of whole group and let the chart calculate correct
                 width for bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \property QBarSeries::count
                 \brief Holds the number of sets in series.
             */
             /*!
                 \property QBarSeries::labelsVisible
                 \brief Defines the visibility of the labels in series
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, int index)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
-                \fn void QBarSeries::barWidthChanged()
+                \fn void QBarSeries::barWidthChanged(qreal)
-                This signal is emitted when bar width has been changed.
+                This signal is emitted when bar width has been changed to \a width.
             */
             /*!
                 \fn void QBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QBarSeries::labelsVisibleChanged()
                  This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
-            /*!
-                Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
-                is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
-                is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
-                Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar. This is
-                because with grouped series it is more logical to set widht of whole group and let the chart calculate correct
-                width for bar.
-                \sa QGroupedBarSeries
-            */
             void QBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QBarSeries);
                 d->setBarWidth(width);
-                emit barWidthChanged();
+                emit barWidthChanged(width);
             }
-            /*!
-                Returns the width of bars.
-            */
             qreal QBarSeries::barWidth() const
             {
                 Q_D(const QBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all of the bar sets from the series
             */
             void QBarSeries::clear()
             {
                 Q_D(QBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::count() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             void QBarSeriesPrivate::setCategories(QStringList categories)
             {
                 m_categories = categories;
             }
             void QBarSeriesPrivate::insertCategory(int index, const QString category)
             {
                 m_categories.insert(index, category);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::removeCategory(int index)
             {
                 m_categories.removeAt(index);
                 emit categoriesUpdated();
             }
             int QBarSeriesPrivate::categoryCount() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories.count();
                 }
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             QStringList QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
                 QStringList categories;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     categories.append(QString::number(i));
                 }
                 return categories;
             }
             void QBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 if ((category >= 0) && (category < m_categories.count())) {
                     return m_categories.at(category);
                 }
                 return QString::number(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth NOTIFY barWidthChanged)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
             public:
                 explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
                 QList<QBarSet*> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 bool isLabelsVisible() const;
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, int index);
                 void hovered(QBarSet* barset, bool status);
-                void barWidthChanged();
+                void barWidthChanged(qreal width);
                 void countChanged();
                 void labelsVisibleChanged();
                 void barsetsAdded(QList<QBarSet*> sets);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +75 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 "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \property QBarSet::label
                 \brief Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
+                \property QBarSet::color
+                \brief The fill (brush) color of the bar set.
+            */
+            /*!
+                \property QBarSet::borderColor
+                \brief The line (pen) color of the bar set.
+            */
+            /*!
+                \property QBarSet::labelColor
+                \brief The text (label) color of the bar set.
+            */
+            /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the barSet has changed.
                 \sa label
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
+                \fn void QBarSet::colorChanged(QColor)
+                This signal is emitted when the fill (brush) color of the set has changed to \a color.
+            */
+            /*!
+                \fn void QBarSet::borderColorChanged(QColor)
+                This signal is emitted when the line (pen) color of the set has changed to \a color.
+            */
+            /*!
+                \fn void QBarSet::labelColorChanged(QColor)
+                This signal is emitted when the text (label) color of the set has changed to \a color.
+            */
+            /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
                 \sa append(), insert()
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             void valueChanged(int index);
             /*!
                 Constructs QBarSet with a label of \a label and with parent of \a parent
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(label,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends a point to set. Parameter \a value x coordinate defines the
                 position in x-axis and y coordinate defines the height of bar.
                 Depending on presentation (QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries)
                 the x values are used or ignored.
             */
             void QBarSet::append(const QPointF value)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of \a values to set. Works like append with single point.
                 \sa append()
             */
             void QBarSet::append(const QList<QPointF> values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Appends new value \a value to the end of set. Internally the value is converted to QPointF,
                 with x coordinate being the index of appended value and y coordinate is the value.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF and use other append(QPointF) method.
                 append(QPointF(d_ptr->m_values.count(), value));
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are converted to QPointF, where x coordinate is the index of point and y coordinate is the value.
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convinience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Convinience operator. Same as append, with QPointF \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const QPointF &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const QPointF value)
             {
                 d_ptr->insert(index,value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 Returns true if remove operation was succesfull.
                 \sa insert()
             */
             bool QBarSet::remove(const int index, const int count)
             {
                 bool success = d_ptr->remove(index,count);
                 if (success) {
                     emit valuesRemoved(index,count);
                 }
                 return success;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 d_ptr->replace(index,value);
                 emit valueChanged(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const QPointF value)
             {
                 d_ptr->replace(index,value);
                 emit valueChanged(index);
             }
             /*!
                 Returns value of set indexed by \a index. Note that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
                 If the index is out of bounds QPointF(0, 0.0) is returned.
             */
             QPointF QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count()) {
                     return QPointF(index, 0.0);
                 }
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns value of set indexed by \a index. ote that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
             */
             QPointF QBarSet::operator [](const int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset. The sum is sum of y coordinates in the QPointF representation.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     //total += d_ptr->m_values.at(i);
                     total += d_ptr->m_values.at(i).y();
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                       emit penChanged();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                   emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
+            QColor QBarSet::color()
+            {
+                return brush().color();
+            }
+            void QBarSet::setColor(QColor color)
+            {
+                QBrush b = brush();
+                if (b.color() != color) {
+                    b.setColor(color);
+                    setBrush(b);
+                    emit colorChanged(color);
+                }
+            }
+            QColor QBarSet::borderColor()
+            {
+                return pen().color();
+            }
+            void QBarSet::setBorderColor(QColor color)
+            {
+                QPen p = pen();
+                if (p.color() != color) {
+                    p.setColor(color);
+                    setPen(p);
+                    emit borderColorChanged(color);
+                }
+            }
+            QColor QBarSet::labelColor()
+            {
+                return labelBrush().color();
+            }
+            void QBarSet::setLabelColor(QColor color)
+            {
+                QBrush b = labelBrush();
+                if (b.color() != color) {
+                    b.setColor(color);
+                    setLabelBrush(b);
+                    emit labelColorChanged(color);
+                }
+            }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 m_values.append(value);
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(values.at(i));
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(QPointF(index,values.at(i)));
                     index++;
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             bool QBarSetPrivate::remove(const int index, const int count)
             {
                 if ((index + count) > m_values.count()) {
                     // cant remove more values than there are
                     return false;
                 }
                 int c = count;
                 while (c > 0) {
                     m_values.removeAt(index);
                     c--;
                 }
                 emit restructuredBars();
                 return true;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index,QPointF(index,value));
                 emit updatedBars();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index,value);
                 emit updatedBars();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

src/xychart/qxyseries.cpp +6 -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$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
-                \property QXYSeries::count
-                Number of points in the series.
-            */
-            /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief Signal is emitted when user replaces a point at \a index.
                 \sa replace()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief Signal is emitted when user adds a point at \a index.
                 \sa append(), insert()
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief Signal is emitted when user removes a point at \a index.
                 \sa remove()
             */
             /*!
+                \fn void QXYSeries::pointsVisibleChanged(bool visible)
+                \brief Signal is emitted when the point visibility has changed to \a visible.
+            */
+            /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
             //    emit d->pointAdded(d->m_points.count()-1);
                 emit pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
                     append(point);
                 }
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
             */
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
             */
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
             //    emit d->pointReplaced(index);
                 emit pointReplaced(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
             //    emit d->pointRemoved(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points.insert(index, point);
             //    emit d->pointAdded(index);
                 emit pointAdded(index);
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 \internal \a pos
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
+                    emit pointsVisibleChanged(visible);
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if(points.isEmpty()){
                     minX=0.0;
                     minY=0.0;
                     maxX=1.0;
                     maxY=1.0;
                 }
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
-                Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
+                Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible NOTIFY pointsVisibleChanged)
-                Q_PROPERTY(int count READ count)
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d,QObject *parent = 0);
             public:
                 ~QXYSeries();
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> &points);
                 void replace(qreal oldX,qreal oldY,qreal newX,qreal newY);
                 void replace(const QPointF &oldPoint,const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> &points);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
+                void pointsVisibleChanged(bool visible);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

tests/auto/qbarset/tst_qbarset.cpp +12 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarset.h>
             #include <qgroupedbarseries.h>
             #include <qchartview.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QBarSet : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarset_data();
                 void qbarset();
                 void label_data();
                 void label();
                 void append_data();
                 void append();
                 void appendOperator_data();
                 void appendOperator();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 void replace_data();
                 void replace();
                 void at_data();
                 void at();
                 void atOperator_data();
                 void atOperator();
                 void count_data();
                 void count();
                 void sum_data();
                 void sum();
                 void customize();
             private:
                 QBarSet* m_barset;
             };
             void tst_QBarSet::initTestCase()
             {
             }
             void tst_QBarSet::cleanupTestCase()
             {
             }
             void tst_QBarSet::init()
             {
                  m_barset = new QBarSet(QString("label"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
                 QBarSet barset(QString("label"));
                 QCOMPARE(barset.label(), QString("label"));
                 QCOMPARE(barset.count(), 0);
                 QVERIFY(qFuzzyIsNull(barset.sum()));
             }
             void tst_QBarSet::label_data()
             {
                 QTest::addColumn<QString> ("label");
                 QTest::addColumn<QString> ("result");
                 QTest::newRow("label0") << QString("label0") << QString("label0");
                 QTest::newRow("label1") << QString("label1") << QString("label1");
             }
             void tst_QBarSet::label()
             {
                 QFETCH(QString, label);
                 QFETCH(QString, result);
                 QSignalSpy labelSpy(m_barset,SIGNAL(labelChanged()));
                 m_barset->setLabel(label);
                 QCOMPARE(m_barset->label(), result);
                 QVERIFY(labelSpy.count() == 1);
             }
             void tst_QBarSet::append_data()
             {
                 QTest::addColumn<int> ("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("100") << 100;
                 QTest::newRow("1000") << 1000;
             }
             void tst_QBarSet::append()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset, SIGNAL(valuesAdded(int,int)));
+                QSignalSpy countSpy(m_barset, SIGNAL(countChanged(int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     m_barset->append(value);
                     QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
-                QVERIFY(valueSpy.count() == count);
+                QCOMPARE(valueSpy.count(), count);
+                QCOMPARE(countSpy.count(), count);
             }
             void tst_QBarSet::appendOperator_data()
             {
                 append_data();
             }
             void tst_QBarSet::appendOperator()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
+                QSignalSpy countSpy(m_barset, SIGNAL(countChanged(int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     *m_barset << value;
                     QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
-                QVERIFY(valueSpy.count() == count);
+                QCOMPARE(valueSpy.count(), count);
+                QCOMPARE(countSpy.count(), count);
             }
             void tst_QBarSet::insert_data()
             {
             }
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
+                QSignalSpy countSpy(m_barset, SIGNAL(countChanged(int)));
                 m_barset->insert(0, 1.0);       // 1.0
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->count(), 1);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 1.0));
                 m_barset->insert(0, 2.0);       // 2.0 1.0
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(1).y(), 1.0);
                 QCOMPARE(m_barset->count(), 2);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 3.0));
                 m_barset->insert(1, 3.0);       // 2.0 3.0 1.0
                 QCOMPARE(m_barset->at(1).y(), 3.0);
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 1.0);
                 QCOMPARE(m_barset->count(), 3);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 6.0));
-                QVERIFY(valueSpy.count() == 3);
+                QCOMPARE(valueSpy.count(), 3);
+                QCOMPARE(countSpy.count(), 3);
             }
             void tst_QBarSet::remove_data()
             {
             }
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesRemoved(int,int)));
+                QSignalSpy countSpy(m_barset, SIGNAL(countChanged(int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->remove(2);                // 1.0 2.0 4.0
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 4.0);
                 QCOMPARE(m_barset->count(), 3);
                 QCOMPARE(m_barset->sum(), 7.0);
                 m_barset->remove(0);                // 2.0 4.0
                 QCOMPARE(m_barset->at(0).y(), 2.0);
                 QCOMPARE(m_barset->at(1).y(), 4.0);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
-                QVERIFY(valueSpy.count() == 2);
+                QCOMPARE(valueSpy.count(), 2);
+                QCOMPARE(countSpy.count(), 6);
             }
             void tst_QBarSet::replace_data()
             {
             }
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valueChanged(int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->replace(0, 5.0);          // 5.0 2.0 3.0 4.0
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 14.0);
                 QCOMPARE(m_barset->at(0).y(), 5.0);
                 m_barset->replace(3, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QCOMPARE(m_barset->at(0).y(), 5.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 3.0);
                 QCOMPARE(m_barset->at(3).y(), 6.0);
                 QVERIFY(valueSpy.count() == 2);
             }
             void tst_QBarSet::at_data()
             {
             }
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->at(1).y(), 2.0);
                 QCOMPARE(m_barset->at(2).y(), 3.0);
                 QCOMPARE(m_barset->at(3).y(), 4.0);
             }
             void tst_QBarSet::atOperator_data()
             {
             }
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->operator [](0).y(), 1.0);
                 QCOMPARE(m_barset->operator [](1).y(), 2.0);
                 QCOMPARE(m_barset->operator [](2).y(), 3.0);
                 QCOMPARE(m_barset->operator [](3).y(), 4.0);
             }
             void tst_QBarSet::count_data()
             {
             }
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
                 m_barset->append(2.0);
                 QCOMPARE(m_barset->count(),2);
                 m_barset->append(3.0);
                 QCOMPARE(m_barset->count(),3);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(),4);
             }
             void tst_QBarSet::sum_data()
             {
             }
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),1.0));
                 m_barset->append(2.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),3.0));
                 m_barset->append(3.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),6.0));
                 m_barset->append(4.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),10.0));
             }
             void tst_QBarSet::customize()
             {
                 // Create sets
                 QBarSet *set1 = new QBarSet("set1");
                 QBarSet *set2 = new QBarSet("set2");
                 // Append set1 to series
                 QGroupedBarSeries *series = new QGroupedBarSeries();
                 bool success = series->append(set1);
                 QVERIFY(success);
                 // Add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
                 // Test pen
                 QVERIFY(set1->pen() != QPen());
                 QVERIFY(set2->pen() == QPen());
                 QPen pen(QColor(128,128,128,128));
                 set1->setPen(pen);
                 QVERIFY(set1->pen() == pen);
                 QVERIFY(set2->pen() == QPen());
                 // Test brush
                 QVERIFY(set1->brush() != QBrush());
                 QVERIFY(set2->brush() == QBrush());
                 QBrush brush(QColor(128,128,128,128));
                 set1->setBrush(brush);
                 QVERIFY(set1->brush() == brush);
                 QVERIFY(set2->brush() == QBrush());
                 // Test label brush
                 QVERIFY(set1->labelBrush() != QBrush());
                 QVERIFY(set2->labelBrush() == QBrush());
                 set1->setLabelBrush(brush);
                 QVERIFY(set1->labelBrush() == brush);
                 QVERIFY(set2->labelBrush() == QBrush());
                 // Test label font
                 // Note: QFont empty constructor creates font with application's default font, so the font may or may not be the
                 // same for the set added to the series  (depending on the QChart's theme configuration)
                 QVERIFY(set1->labelFont() != QFont() || set1->labelFont() == QFont());
                 QVERIFY(set2->labelFont() == QFont());
                 QFont font;
                 font.setBold(true);
                 font.setItalic(true);
                 set1->setLabelFont(font);
                 QVERIFY(set1->labelFont() == font);
                 QVERIFY(set2->labelFont() == QFont());
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
             }
             QTEST_MAIN(tst_QBarSet)
             #include "tst_qbarset.moc"

tests/qmlchartproperties/qml/qmlchartproperties/BarEditor.qml +6 -5

             /****************************************************************************
             **
             ** 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.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
                     seriesConnections.target = series;
                     setConnections.target = series.at(0);
                 }
                 Connections {
                     id: seriesConnections
                     ignoreUnknownSignals: true
                     onNameChanged:              console.log("series.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
+                    onBarWidthChanged:          console.log("series.onBardWidthChanged: " + width)
                     onLabelsVisibleChanged:     console.log("series.onLabelsVisibleChanged: " + series.labelsVisible);
-                    onCountChanged:             console.log("series.onCountChanged: " + series.count);
+                    onCountChanged:             console.log("series.onCountChanged: " + count);
                 }
                 Connections {
                     id: setConnections
                     ignoreUnknownSignals: true
-                    onColorChanged:             console.log("series.onColorChanged: " + series.color);
+                    onColorChanged:             console.log("series.onColorChanged: " + color);
-                    onBorderColorChanged:       console.log("series.onBorderColorChanged: " + series.borderColor);
+                    onBorderColorChanged:       console.log("series.onBorderColorChanged: " + color);
-                    onLabelColorChanged:        console.log("series.onLabelColorChanged: " + series.labelColor);
+                    onLabelColorChanged:        console.log("series.onLabelColorChanged: " + color);
-                    onCountChanged:             console.log("series.onCountChanged: " + series.count);
+                    onCountChanged:             console.log("series.onCountChanged: " + count);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "labels visible"
                     onClicked: series.labelsVisible = !series.labelsVisible;
                 }
                 Button {
                     text: "bar width +"
                     onClicked: series.barWidth += 0.1;
                 }
                 Button {
                     text: "bar width -"
                     onClicked: series.barWidth -= 0.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 label color"
                     onClicked: series.at(0).labelColor = main.nextColor();
                 }
                 Button {
                     text: "set 1 font size +"
                     onClicked: series.at(0).labelFont.pixelSize += 1;
                 }
                 Button {
                     text: "set 1 font size -"
                     onClicked: series.at(0).labelFont.pixelSize -= 1;
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ChartEditor.qml +44 -8

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series // TODO: rename to chart
                 onSeriesChanged: {
                     legendConnections.target = series.legend;
                     axisXConnections.target = series.axisX;
                     axisYConnections.target = series.axisY;
                 }
                 Connections {
                     target: series
                     ignoreUnknownSignals: true
                     onVisibleChanged:           console.log("chart.onVisibleChanged: " + series.visible);
                     onThemeChanged:             console.log("chart.onThemeChanged: " + series.theme);
                     onLegendChanged:            console.log("chart.onLegendChanged: " + series.legend);
                     onAnimationOptionsChanged:  console.log("chart.onAnimationOptionsChanged: " + series.animationOptions);
                     onTitleColorChanged:        console.log("chart.onTitleColorChanged: " + series.titleColor);
                     onBackgroundColorChanged:   console.log("chart.onBackgroundColorChanged: " + series.backgroundColor);
                     onDropShadowEnabledChanged: console.log("chart.onDropShadowEnabledChanged: " + enabled);
                 }
                 Connections {
                     id: legendConnections
                     ignoreUnknownSignals: true
                     onAlignmentChanged:         console.log("legend.onAlignmentChanged: " + alignment);
                     onVisibleChanged:           console.log("legend.onVisibleChanged: " + series.legend.visible);
                     onBackgroundVisibleChanged: console.log("legend.onBackgroundVisibleChanged: " + visible);
                     onColorChanged:             console.log("legend.onColorChanged: " + color);
                     onBorderColorChanged:       console.log("legend.onBorderColorChanged: " + color);
                 }
                 Connections {
                     id: axisXConnections
                     ignoreUnknownSignals: true
                     onColorChanged:                 console.log("axisX.onColorChanged: " + color);
                     onLabelsVisibleChanged:         console.log("axisX.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:           console.log("axisX.onLabelsColorChanged: " + color);
                     onLabelsAngleChanged:           console.log("axisX.onLabelsAngleChanged: " + angle);
                     onVisibleChanged:               console.log("axisX.onVisibleChanged: " + visible);
                     onGridVisibleChanged:           console.log("axisX.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:         console.log("axisX.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:           console.log("axisX.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:     console.log("axisX.onShadesBorderColorChanged: " + color);
-                    onNiceNumbersEnabledChanged:    console.log("axisX.onNiceNumbersEnabledChanged: " + enabled);
+                    onMinChanged:                   console.log("axisX.onMinChanged: " + min);
+                    onMaxChanged:                   console.log("axisX.onMaxChanged: " + max);
                     onTicksCountChanged:            console.log("axisX.onTicksCountChanged: " + count);
+                    onNiceNumbersEnabledChanged:    console.log("axisX.onNiceNumbersEnabledChanged: " + enabled);
                 }
                 Connections {
                     id: axisYConnections
                     ignoreUnknownSignals: true
                     onColorChanged:                 console.log("axisY.onColorChanged: " + color);
                     onLabelsVisibleChanged:         console.log("axisY.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:           console.log("axisY.onLabelsColorChanged: " + color);
                     onLabelsAngleChanged:           console.log("axisY.onLabelsAngleChanged: " + angle);
                     onVisibleChanged:               console.log("axisY.onVisibleChanged: " + visible);
                     onGridVisibleChanged:           console.log("axisY.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:         console.log("axisY.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:           console.log("axisY.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:     console.log("axisY.onShadesBorderColorChanged: " + color);
-                    onNiceNumbersEnabledChanged:    console.log("axisY.onNiceNumbersEnabledChanged: " + enabled);
+                    onMinChanged:                   console.log("axisY.onMinChanged: " + min);
+                    onMaxChanged:                   console.log("axisY.onMaxChanged: " + max);
                     onTicksCountChanged:            console.log("axisY.onTicksCountChanged: " + count);
+                    onNiceNumbersEnabledChanged:    console.log("axisY.onNiceNumbersEnabledChanged: " + enabled);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "theme +"
                     onClicked: series.theme++;
                 }
                 Button {
                     text: "theme -"
                     onClicked: series.theme--;
                 }
                 Button {
                     text: "animation opt +"
                     onClicked: series.animationOptions++;
                 }
                 Button {
                     text: "animation opt -"
                     onClicked: series.animationOptions--;
                 }
                 Button {
                     text: "title color"
                     onClicked: series.titleColor = main.nextColor();
                 }
                 Button {
                     text: "background color"
                     onClicked: series.backgroundColor = main.nextColor();
                 }
                 Button {
                     text: "drop shadow enabled"
                     onClicked: series.dropShadowEnabled = !series.dropShadowEnabled;
                 }
                 Button {
                     text: "zoom +"
                     onClicked: series.zoom(2);
                 }
                 Button {
                     text: "zoom -"
                     onClicked: series.zoom(0.5);
                 }
                 Button {
                     text: "scroll left"
                     onClicked: series.scrollLeft(10);
                 }
                 Button {
                     text: "scroll right"
                     onClicked: series.scrollRight(10);
                 }
                 Button {
                     text: "scroll up"
                     onClicked: series.scrollUp(10);
                 }
                 Button {
                     text: "scroll down"
                     onClicked: series.scrollDown(10);
                 }
                 Button {
                     text: "legend visible"
                     onClicked: series.legend.visible = !series.legend.visible;
                 }
                 Button {
                     text: "legend bckgrd visible"
                     onClicked: series.legend.backgroundVisible = !series.legend.backgroundVisible;
                 }
                 Button {
                     text: "legend color"
                     onClicked: series.legend.color = main.nextColor();
                 }
                 Button {
                     text: "legend border color"
                     onClicked: series.legend.borderColor = main.nextColor();
                 }
                 Button {
                     text: "legend top"
                     onClicked: series.legend.alignment ^= Qt.AlignTop;
                 }
                 Button {
                     text: "legend bottom"
                     onClicked: series.legend.alignment ^= Qt.AlignBottom;
                 }
                 Button {
                     text: "legend left"
                     onClicked: series.legend.alignment ^= Qt.AlignLeft;
                 }
                 Button {
                     text: "legend right"
                     onClicked: series.legend.alignment ^= Qt.AlignRight;
                 }
                 Button {
-                    text: "axis X nice nmb"
-                    onClicked: series.axisX.niceNumbersEnabled = !series.axisX.niceNumbersEnabled;
-                Button {
                     text: "axis X visible"
                     onClicked: series.axisX.visible = !series.axisX.visible;
                 }
                 Button {
                     text: "axis X grid visible"
                     onClicked: series.axisX.gridVisible = !series.axisX.gridVisible;
                 }
                 Button {
                     text: "axis X labels visible"
                     onClicked: series.axisX.labelsVisible = !series.axisX.labelsVisible;
                 }
                 Button {
                     text: "axis X color"
                     onClicked: series.axisX.color = main.nextColor();
                 }
                 Button {
                     text: "axis X labels color"
                     onClicked: series.axisX.labelsColor = main.nextColor();
                 }
                 Button {
                     text: "axis X labels angle +"
                     onClicked: series.axisX.labelsAngle += 5;
                 }
                 Button {
                     text: "axis X labels angle -"
                     onClicked: series.axisX.labelsAngle -= 5;
                 }
                 Button {
                     text: "axis X shades visible"
                     onClicked: series.axisX.shadesVisible = !series.axisX.shadesVisible;
                 }
                 Button {
                     text: "axis X shades color"
                     onClicked: series.axisX.shadesColor = main.nextColor();
                 }
                 Button {
                     text: "axis X shades bcolor"
                     onClicked: series.axisX.shadesBorderColor = main.nextColor();
                 }
                 Button {
+                    text: "axis X max +"
+                    onClicked: series.axisX.max += 0.1;
+                }
+                Button {
+                    text: "axis X max -"
+                    onClicked: series.axisX.max -= 0.1;
+                }
+                Button {
+                    text: "axis X min +"
+                    onClicked: series.axisX.min += 0.1;
+                }
+                Button {
+                    text: "axis X min -"
+                    onClicked: series.axisX.min -= 0.1;
+                }
+                Button {
                     text: "axis X ticks count +"
                     onClicked: series.axisX.ticksCount++;
                 }
                 Button {
                     text: "axis X ticks count -"
                     onClicked: series.axisX.ticksCount--;
                 }
                 Button {
-                    text: "axis Y nice nmb"
+                    text: "axis X nice nmb"
-                    onClicked: series.axisY.niceNumbersEnabled = !series.axisY.niceNumbersEnabled;
+                    onClicked: series.axisX.niceNumbersEnabled = !series.axisX.niceNumbersEnabled;
                 }
                 Button {
                     text: "axis Y visible"
                     onClicked: series.axisY.visible = !series.axisY.visible;
                 }
                 Button {
                     text: "axis Y grid visible"
                     onClicked: series.axisY.gridVisible = !series.axisY.gridVisible;
                 }
                 Button {
                     text: "axis Y labels visible"
                     onClicked: series.axisY.labelsVisible = !series.axisY.labelsVisible;
                 }
                 Button {
                     text: "axis Y color"
                     onClicked: series.axisY.color = main.nextColor();
                 }
                 Button {
                     text: "axis Y labels color"
                     onClicked: series.axisY.labelsColor = main.nextColor();
                 }
                 Button {
                     text: "axis Y labels angle +"
                     onClicked: series.axisY.labelsAngle += 5;
                 }
                 Button {
                     text: "axis Y labels angle -"
                     onClicked: series.axisY.labelsAngle -= 5;
                 }
                 Button {
                     text: "axis Y shades visible"
                     onClicked: series.axisY.shadesVisible = !series.axisY.shadesVisible;
                 }
                 Button {
                     text: "axis Y shades color"
                     onClicked: series.axisY.shadesColor = main.nextColor();
                 }
                 Button {
                     text: "axis Y shades bcolor"
                     onClicked: series.axisY.shadesBorderColor = main.nextColor();
                 }
                 Button {
+                    text: "axis Y max +"
+                    onClicked: series.axisY.max += 0.1;
+                }
+                Button {
+                    text: "axis Y max -"
+                    onClicked: series.axisY.max -= 0.1;
+                }
+                Button {
+                    text: "axis Y min +"
+                    onClicked: series.axisY.min += 0.1;
+                }
+                Button {
+                    text: "axis Y min -"
+                    onClicked: series.axisY.min -= 0.1;
+                }
+                Button {
                     text: "axis Y ticks count +"
                     onClicked: series.axisY.ticksCount++;
                 }
                 Button {
                     text: "axis Y ticks count -"
                     onClicked: series.axisY.ticksCount--;
                 }
+                Button {
+                    text: "axis Y nice nmb"
+                    onClicked: series.axisY.niceNumbersEnabled = !series.axisY.niceNumbersEnabled;
+                }
             }

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