HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1481:3fafc6aab8aa

color and borderColor properties to XY charts; removed unnecessary signals

Tero Ahola -

r1481:3fafc6aab8aa

parent child

Context file:

r1481:3fafc6aab8aa

Expand all files

plugins/declarative/declarativeareaseries.cpp 0 -24

             /****************************************************************************
             **
             ** 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 "declarativeareaseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass AreaSeries QAreaSeries
                 \section1 Example Usage
                 \beginfloatleft
                 \image demos_qmlchart4.png
                 \endfloat
                 \clearfloat
                 The following QML shows how to create a simple area chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
             */
             DeclarativeAreaSeries::DeclarativeAreaSeries(QObject *parent) :
                 QAreaSeries(parent)
             {
             }
             void DeclarativeAreaSeries::setUpperSeries(DeclarativeLineSeries* series)
             {
                 QAreaSeries::setUpperSeries(series);
             }
             DeclarativeLineSeries* DeclarativeAreaSeries::upperSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::upperSeries());
             }
             void DeclarativeAreaSeries::setLowerSeries(DeclarativeLineSeries* series)
             {
                 QAreaSeries::setLowerSeries(series);
             }
             DeclarativeLineSeries* DeclarativeAreaSeries::lowerSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::lowerSeries());
             }
-            QColor DeclarativeAreaSeries::penColor() const
-                return pen().color();
-            void DeclarativeAreaSeries::setPenColor(QColor color)
-                QPen p = pen();
-                p.setColor(color);
-                setPen(p);
-            QColor DeclarativeAreaSeries::brushColor() const
-                return brush().color();
-            void DeclarativeAreaSeries::setBrushColor(QColor color)
-                QBrush b = brush();
-                b.setColor(color);
-                setBrush(b);
             #include "moc_declarativeareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativeareaseries.h 0 -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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEAREASERIES_H
             #define DECLARATIVEAREASERIES_H
             #include "qchartglobal.h"
             #include "qareaseries.h"
             #include "declarativelineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeAreaSeries : public QAreaSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(DeclarativeLineSeries *upperSeries READ upperSeries WRITE setUpperSeries)
                 Q_PROPERTY(DeclarativeLineSeries *lowerSeries READ lowerSeries WRITE setLowerSeries)
-                Q_PROPERTY(QColor color READ brushColor WRITE setBrushColor)
-                Q_PROPERTY(QColor borderColor READ penColor WRITE setPenColor)
             public:
                 explicit DeclarativeAreaSeries(QObject *parent = 0);
                 void setUpperSeries(DeclarativeLineSeries* series);
                 DeclarativeLineSeries* upperSeries() const;
                 void setLowerSeries(DeclarativeLineSeries* series);
                 DeclarativeLineSeries* lowerSeries() const;
-                QColor penColor() const;
-                void setPenColor(QColor color);
-                QColor brushColor() const;
-                void setBrushColor(QColor color);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEAREASERIES_H

plugins/declarative/declarativechart.cpp +3 -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$
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple line chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
                 \beginfloatleft
                 \image demos_qmlchart2.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animation
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty string ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Axis ChartView::axisX
               The x-axis of the chart.
             */
             /*!
               \qmlproperty Axis ChartView::axisY
               The default y-axis of the chart.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(QAbstractSeries *series)
               The y-axis of the series. This is the same as the default y-axis of the chart, unless you have
               explicitly defined the series to have a non-default y-axis.
             */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         // TODO: how about optional y-axis?
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }
                 }
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
-                if (chartTheme != m_chart->theme()) {
+                if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
-                    themeChanged();
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
-                if (animationOptions != m_chart->animationOptions()) {
+                if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
-                    animationOptionsChanged();
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
-                if (title != m_chart->title()) {
+                if (title != m_chart->title())
                     m_chart->setTitle(title);
-                    emit titleChanged();
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAxis *DeclarativeChart::axisX()
             {
                 return m_chart->axisX();
             }
             QAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             QVariantList DeclarativeChart::axisXLabels()
             {
                 QVariantList labels;
                 foreach (qreal value, m_chart->axisX()->categories()->values()) {
                     labels.append(value);
                     labels.append(m_chart->axisX()->categories()->label(value));
                 }
                 return labels;
             }
             void DeclarativeChart::setAxisXLabels(QVariantList list)
             {
                 QVariant value(QVariant::Invalid);
                 foreach (QVariant element, list) {
                     if (value.isValid() && element.type() == QVariant::String) {
                         m_chart->axisX()->categories()->insert(value.toDouble(), element.toString());
                         value = QVariant(QVariant::Invalid);
                     } else {
                         if (element.canConvert(QVariant::Double))
                             value = element;
                     }
                 }
                 emit axisLabelsChanged();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged();
                 }
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(QPointF(pixels, 0));
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(QPointF(-pixels, 0));
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, pixels));
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, -pixels));
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypeGroupedBar:
                     series = new DeclarativeGroupedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativechart.h +3 -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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <QtCore/QtGlobal>
             #include <QDeclarativeItem>
             #include <qchart.h>
             #include <QAxis>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // TODO: Derive from QChart for easier definition of properties?
             class DeclarativeChart : public QDeclarativeItem
             // TODO: for QTQUICK2: extend QQuickPainterItem instead
             //class DeclarativeChart : public QQuickPaintedItem, public Chart
             {
                 Q_OBJECT
-                Q_PROPERTY(Theme theme READ theme WRITE setTheme NOTIFY themeChanged)
+                Q_PROPERTY(Theme theme READ theme WRITE setTheme)
-                Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions NOTIFY animationOptionsChanged)
+                Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
-                Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
+                Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QAxis *axisX READ axisX)
                 Q_PROPERTY(QAxis *axisY READ axisY)
                 Q_PROPERTY(QLegend *legend READ legend)
                 // TODO: how to define axis labels? This is not very convenient
                 Q_PROPERTY(QVariantList axisXLabels READ axisXLabels WRITE setAxisXLabels NOTIFY axisLabelsChanged)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)
                 Q_PROPERTY(bool dropShadowEnabled READ dropShadowEnabled WRITE setDropShadowEnabled NOTIFY dropShadowEnabledChanged)
                 Q_ENUMS(Animation)
                 Q_ENUMS(Theme)
                 Q_ENUMS(SeriesType)
             public:
                 // duplicating enums from QChart to make the QML api namings 1-to-1 with the C++ api
                 enum Theme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum Animation {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypeGroupedBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             public:
                 DeclarativeChart(QDeclarativeItem *parent = 0);
                 ~DeclarativeChart();
             public: // From QDeclarativeItem/QGraphicsItem
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
                 void paint (QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setTitle(QString title);
                 QString title();
                 QAxis *axisX();
                 Q_INVOKABLE QAxis *axisY(QAbstractSeries *series = 0);
                 QLegend *legend();
                 QVariantList axisXLabels();
                 void setAxisXLabels(QVariantList list);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 Q_INVOKABLE void zoom(qreal factor);
                 Q_INVOKABLE void scrollLeft(qreal pixels);
                 Q_INVOKABLE void scrollRight(qreal pixels);
                 Q_INVOKABLE void scrollUp(qreal pixels);
                 Q_INVOKABLE void scrollDown(qreal pixels);
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(DeclarativeChart::SeriesType type, QString name = "");
             Q_SIGNALS:
-                void themeChanged();
-                void animationOptionsChanged();
-                void titleChanged();
                 void axisLabelsChanged();
                 void titleColorChanged();
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
             public:
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECHART_H

plugins/declarative/declarativelineseries.h 0 -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 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 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativescatterseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ScatterSeries QScatterSeries
                 The following QML shows how to create a chart with two simple scatter series:
                 \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
                 \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 2
                 \beginfloatleft
                 \image demos_qmlchart5.png
                 \endfloat
                 \clearfloat
             */
             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)
             {
                 Q_UNUSED(list)
                 Q_UNUSED(element)
                 // Empty implementation, childs are parsed in componentComplete
             }
-            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 0 -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 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.h 0 -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 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 0 -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 "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)) {
                         DeclarativeXyPoint *point = 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/declarativexyseries.h 0 -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 DECLARATIVE_XY_SERIES_H
             #define DECLARATIVE_XY_SERIES_H
             #include "qchartglobal.h"
             #include "declarativexypoint.h"
             #include <QColor>
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QAbstractSeries;
             class DeclarativeXySeries
             {
             public:
                 explicit DeclarativeXySeries();
                 ~DeclarativeXySeries();
             public:
                 void classBegin();
                 void componentComplete();
                 virtual QXYSeries *xySeries() = 0;
-                QColor penColor();
-                void setPenColor(QColor color);
                 DeclarativeXyPoint *at(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVE_XY_SERIES_H

src/areachart/qareaseries.cpp +53 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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
+                \property QAreaSeries::color
+                Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
+                \sa QAreaSeries::brush()
+            */
+            /*!
+                \property QAreaSeries::borderColor
+                Line (pen) color of the series. This is a convenience property for modifying the color of pen.
+                \sa QAreaSeries::pen()
+            */
+            /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
+                \fn void QAreaSeries::colorChanged(QColor color)
+                \brief Signal is emitted when the fill (brush) color has changed to \a color.
+            */
+            /*!
+                \fn void QAreaSeries::borderColorChanged(QColor color)
+                \brief Signal is emitted when the line (pen) color has changed to \a color.
+            */
+            /*!
                \fn bool  QAreaSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
+            void QAreaSeries::setColor(const QColor &color)
+            {
+                QBrush b = brush();
+                if (b.color() != color) {
+                    b.setColor(color);
+                    setBrush(b);
+                    emit colorChanged(color);
+                }
+            }
+            QColor QAreaSeries::color() const
+            {
+                return brush().color();
+            }
+            void QAreaSeries::setBorderColor(const QColor &color)
+            {
+                QPen p = pen();
+                if (p.color() != color) {
+                    p.setColor(color);
+                    setPen(p);
+                    emit borderColorChanged(color);
+                }
+            }
+            QColor QAreaSeries::borderColor() const
+            {
+                return pen().color();
+            }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 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);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     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);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimator(presenter->animator());
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
                         area->lowerLineItem()->setAnimator(presenter->animator());
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.h +12 -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 QAREASERIES_H
             #define QAREASERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QAreaSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QAbstractSeries *upperSeries READ upperSeries)
                 Q_PROPERTY(QAbstractSeries *lowerSeries READ lowerSeries)
+                Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
+                Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
             public:
                 explicit QAreaSeries(QObject *parent = 0);
                 explicit QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries = 0);
                 ~QAreaSeries();
             public:
                 QAbstractSeries::SeriesType type() const;
                 void setUpperSeries(QLineSeries* series);
                 QLineSeries* upperSeries() const;
                 void setLowerSeries(QLineSeries* series);
                 QLineSeries* lowerSeries() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
+                void setColor(const QColor &color);
+                QColor color() const;
+                void setBorderColor(const QColor &color);
+                QColor borderColor() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void selected();
+                void colorChanged(QColor color);
+                void borderColorChanged(QColor color);
             private:
-                Q_DECLARE_PRIVATE(QAreaSeries);
+                Q_DECLARE_PRIVATE(QAreaSeries)
-                Q_DISABLE_COPY(QAreaSeries);
+                Q_DISABLE_COPY(QAreaSeries)
                 friend class AreaLegendMarker;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qaxis.cpp 0 -20

             /****************************************************************************
             **
             ** 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 "qaxis.h"
             #include "qaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAxis
                 \brief The QAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool Axis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \property QAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool Axis::visible
               The visibility of the axis.
             */
             /*!
               \property QAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool Axis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color Axis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color Axis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int Axis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool Axis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int Axis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool Axis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \fn void QAxis::visibleChanged(bool)
               Visiblity of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::labelsVisibleChanged(bool)
               Visiblity of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::gridVisibleChanged(bool)
               Visiblity of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \fn QChartAxisCategories* QAxis::categories()
               Returns pointer to the list of categories which correspond to the values on the axis.
             */
             /*!
               \fn void QAxis::colorChanged(QColor)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAxis::labelsColorChanged(QColor)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
-              \fn void QAxis::labelsAngleChanged(int)
-              Emitted if the \a angle of the axis labels is changed.
-            */
-            /*!
               \fn void QAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAxis::shadesColorChanged(QColor)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
-              \fn void QAxis::ticksCountChanged(int count)
-              \brief Emits the new \a count of ticks on the axis
-              Signal is emitted when the number of the ticks on the axis has been changed to a different value.
-              Parementer count\a count is the new number of ticks on the axis.
-            */
-            /*!
-              \fn void QAxis::niceNumbersEnabledChanged(bool)
-              Nice numbers algorithm was \a enabled or disabled.
-            */
-            /*!
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAxis::QAxis(QObject *parent) : QObject(parent),
             d_ptr(new QAxisPrivate(this))
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAxis::~QAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             void QAxis::setAxisPenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setAxisPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAxis::axisPenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAxis::setAxisVisible(bool visible)
             {
                 if (d_ptr->m_axisVisible != visible) {
                     d_ptr->m_axisVisible = visible;
                     emit d_ptr->updated();
                     emit visibleChanged(visible);
             	}
             }
             bool QAxis::isAxisVisible() const
             {
                 return d_ptr->m_axisVisible;
             }
             void QAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
                     emit gridVisibleChanged(visible);
             	}
             }
             bool QAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
                     emit labelsVisibleChanged(visible);
             	}
             }
             bool QAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
-                    emit labelsAngleChanged(angle);
             	}
             }
             int QAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
                     emit shadesVisibleChanged(visible);
             	}
             }
             bool QAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
                     emit shadesColorChanged(brush.color());
                 }
             }
             /*!
                \brief Returns brush used to draw shades.
             */
             QBrush QAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 b.setColor(color);
                 setShadesBrush(b);
             }
             QColor QAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 p.setColor(color);
                 setShadesPen(p);
             }
             QColor QAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             void QAxis::setMin(qreal min)
             {
             	setRange(min,d_ptr->m_max);
             }
             qreal QAxis::min() const
             {
                 return d_ptr->m_min;
             }
             void QAxis::setMax(qreal max)
             {
                 setRange(d_ptr->m_min,max);
             }
             qreal QAxis::max() const
             {
                 return d_ptr->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if (!qFuzzyIsNull(d_ptr->m_min - min)) {
                     d_ptr->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d_ptr->m_max - max)) {
                     d_ptr->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(d_ptr->m_min,d_ptr->m_max);
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QAxis::setTicksCount(int count)
             {
                 if (d_ptr->m_ticksCount != count) {
                     d_ptr->m_ticksCount = count;
-            		emit ticksCountChanged(count);
             		emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
             	}
             }
             /*!
               \fn int QAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QAxis::ticksCount() const
             {
                 return d_ptr->m_ticksCount;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAxis::show()
             {
                 d_ptr->m_axisVisible=true;
                 d_ptr->m_gridLineVisible=true;
                 d_ptr->m_labelsVisible=true;
                 d_ptr->m_shadesVisible=true;
                 emit d_ptr->updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAxis::hide()
             {
                 d_ptr->m_axisVisible = false;
                 d_ptr->m_gridLineVisible = false;
                 d_ptr->m_labelsVisible = false;
                 d_ptr->m_shadesVisible = false;
                 emit d_ptr->updated();
             }
             void QAxis::setNiceNumbersEnabled(bool enable)
             {
                 if (d_ptr->m_niceNumbers != enable){
                     d_ptr->m_niceNumbers = enable;
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
-                    emit niceNumbersEnabledChanged(enable);
                 }
             }
             bool  QAxis::niceNumbersEnabled() const
             {
                 return d_ptr->m_niceNumbers;
             }
             QAxisCategories* QAxis::categories()
             {
                 return &d_ptr->m_category;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAxisPrivate::QAxisPrivate(QAxis* q):
                 q_ptr(q),
                 m_axisVisible(true),
                 m_gridLineVisible(true),
                 m_labelsVisible(true),
                 m_labelsAngle(0),
                 m_shadesVisible(false),
                 m_shadesBrush(Qt::SolidPattern),
                 m_shadesOpacity(1.0),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(5),
                 m_niceNumbers(false)
             {
             }
             QAxisPrivate::~QAxisPrivate()
             {
             }
             void QAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                q_ptr->setRange(min,max);
                q_ptr->setTicksCount(count);
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qaxis.cpp"
             #include "moc_qaxis_p.cpp"

src/axis/qaxis.h +3 -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$
             **
             ****************************************************************************/
             #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(int labelsAngle READ labelsAngle WRITE setLabelsAngle)
                 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 NOTIFY minChanged)
                 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
-                Q_PROPERTY(int ticksCount READ ticksCount WRITE setTicksCount NOTIFY ticksCountChanged)
+                Q_PROPERTY(int ticksCount READ ticksCount WRITE setTicksCount)
-                Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled NOTIFY niceNumbersEnabledChanged)
+                Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled)
             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 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/legend/qlegend.cpp 0 -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 "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
-                \fn void QLegend::alignmentChanged(Qt::Alignment)
-                Emitted when the \a alignment of the legend changes.
-            */
-            /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              Bounding rect of legend.
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
-                    alignmentChanged(alignment);
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->attachToChart();
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_chart(chart),
                 m_markers(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_offsetX(0),
                 m_offsetY(0),
                 m_minWidth(0),
                 m_minHeight(0),
                 m_width(0),
                 m_height(0),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         scrollHorizontal = true;
                         break;
                     }
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         scrollHorizontal = false;
                         break;
                     }
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_attachedToChart) {
                     scrollHorizontal = !scrollHorizontal;
                 }
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if(m_width<=m_rect.width()) return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_markers->setPos(-m_offsetX,m_rect.top());
                     }
                 } else {
                     if(m_height<=m_rect.height()) return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_markers->setPos(m_rect.left(),-m_offsetY);
                     }
                 }
             }
             QPointF QLegendPrivate::offset() const
             {
                 return QPointF(m_offsetX,m_offsetY);
             }
             void QLegendPrivate::updateLayout()
             {
                 if (!m_attachedToChart) {
                     updateDetachedLayout();
                     return;
                 }
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             if (item->isVisible()) {
                                 item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 m_minWidth=qMax(m_minWidth,w);
                                 m_minHeight=qMax(m_minHeight,rect.height());
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             if (item->isVisible()) {
                                 item->setPos(point);
                                 const QRectF& rect = item->boundingRect();
                                 qreal h = rect.height();
                                 m_minWidth=qMax(m_minWidth,rect.width());
                                 m_minHeight=qMax(m_minHeight,h);
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_minOffsetX = 0;
                 m_minOffsetY = 0;
                 m_maxOffsetX = m_width - m_rect.width();
                 m_maxOffsetY = m_height - m_rect.height();
                 m_presenter->updateLayout();
             }
             void QLegendPrivate::updateDetachedLayout()
             {
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX=0;
                 m_offsetY=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth = 0;
                 m_minHeight = 0;
                 switch (m_alignment) {
                     case Qt::AlignTop: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,w);
                                 m_minHeight = qMax(m_minHeight,rect.height());
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y());
                                 point.setX(point.x() + w);
                                 if (point.x() + w > m_rect.topLeft().x() + m_rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(m_rect.topLeft().x());
                                     point.setY(point.y() + h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.bottomLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,w);
                                 m_minHeight = qMax(m_minHeight,rect.height());
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y() - h);
                                 point.setX(point.x() + w);
                                 if (point.x() + w > m_rect.bottomLeft().x() + m_rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(m_rect.bottomLeft().x());
                                     point.setY(point.y() - h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = qMin(m_rect.topLeft().y(), m_rect.topLeft().y() - m_height + m_rect.height());
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = 0;
                     }
                     break;
                     case Qt::AlignLeft: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,rect.width());
                                 m_minHeight = qMax(m_minHeight,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x(),point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() + maxWidth);
                                     point.setY(m_rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topRight();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,rect.width());
                                 m_minHeight = qMax(m_minHeight,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x() - w,point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() - maxWidth);
                                     point.setY(m_rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = qMin(m_rect.topLeft().x(), m_rect.topLeft().x() - m_width + m_rect.width());
                         m_minOffsetY = 0;
                         m_maxOffsetX = 0;
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     default:
                     break;
                 }
             }
             void QLegendPrivate::attachToChart()
             {
                 m_attachedToChart = true;
                 q_ptr->setParent(m_chart);
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers)
                     m_markers->addToGroup(marker);
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         marker->setVisible(!marker->isVisible());
                     }
                 }
                 updateLayout();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
-                Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
+                Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 qreal minWidth() const;
                 qreal minHeight() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
-                void alignmentChanged(Qt::Alignment alignment);
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/scatterchart/qscatterseries.cpp +52 -23

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
-              \property QScatterSeries::markerShape
+                \property QScatterSeries::color
+                Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
-              Defines the shape of the marker used to draw the points in the series.
+                \sa QScatterSeries::brush()
             */
             /*!
-                \fn void QScatterSeries::markerShapeChanged()
+                \property QScatterSeries::borderColor
-                Emitted when marker shape is changed
+                Line (pen) color of the series. This is a convenience property for modifying the color of pen.
+                \sa QScatterSeries::pen()
             */
             /*!
-                \fn void QScatterSeries::markerSizeChanged()
+              \property QScatterSeries::markerShape
-                Emitted when marker size is changed
+              Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
             */
             /*!
               \property QScatterSeries::markerSize
-              Defines the size of the marker used to draw the points in the series.
+              Defines the size of the marker used to draw the points in the series. The default size is 15.0.
+            */
+            /*!
+                \fn void QScatterSeries::colorChanged(QColor color)
+                \brief Signal is emitted when the fill (brush) color has changed to \a color.
+            */
+            /*!
+                \fn void QScatterSeries::borderColorChanged(QColor color)
+                \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
-            /*!
+            void QScatterSeries::setColor(const QColor &color)
-                Returns the shape used for drawing markers.
-            */
+                QBrush b = brush();
+                if (b.color() != color) {
+                    b.setColor(color);
+                    setBrush(b);
+                    emit colorChanged(color);
+                }
+            }
+            QColor QScatterSeries::color() const
+            {
+                return brush().color();
+            }
+            void QScatterSeries::setBorderColor(const QColor &color)
+            {
+                QPen p = pen();
+                if (p.color() != color) {
+                    p.setColor(color);
+                    setPen(p);
+                    emit borderColorChanged(color);
+                }
+            }
+            QColor QScatterSeries::borderColor() const
+            {
+                return pen().color();
+            }
             QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
-            /*!
-                Overrides the default shape of the marker items with a user defined \a shape. The default shape
-                is defined by chart theme setting.
-            */
             void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
-                    emit markerShapeChanged();
+                    emit d->updated();
                 }
             }
-            /*!
-                Returns the size of the marker items.
-            */
             qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
-            /*!
-                Set the \a size of the marker items. The default size is 15.
-            */
             void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyIsNull(d->m_size - size)) {
                     d->m_size = size;
-                    emit markerSizeChanged();
+                    emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q):QXYSeriesPrivate(q),
                m_shape(QScatterSeries::MarkerShapeCircle),
                m_size(15.0)
             {
             };
             Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     scatter->setAnimator(presenter->animator());
                     scatter->setAnimation(new XYAnimation(scatter));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.h +10 -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$
             **
             ****************************************************************************/
             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include <qchartglobal.h>
             #include <qxyseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
                 Q_OBJECT
-                Q_PROPERTY(MarkerShape markerShape READ markerShape WRITE setMarkerShape NOTIFY markerShapeChanged)
+                Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
-                Q_PROPERTY(qreal markerSize READ markerSize WRITE setMarkerSize NOTIFY markerSizeChanged)
+                Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
+                Q_PROPERTY(MarkerShape markerShape READ markerShape WRITE setMarkerShape)
+                Q_PROPERTY(qreal markerSize READ markerSize WRITE setMarkerSize)
                 Q_ENUMS(MarkerShape)
             public:
                 enum MarkerShape {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             public:
                 explicit QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
                 QAbstractSeries::SeriesType type() const;
+                void setColor(const QColor &color);
+                QColor color() const;
+                void setBorderColor(const QColor &color);
+                QColor borderColor() const;
                 MarkerShape markerShape() const;
                 void setMarkerShape(MarkerShape shape);
                 qreal markerSize() const;
                 void setMarkerSize(qreal size);
             Q_SIGNALS:
-                void markerShapeChanged();
+                void colorChanged(QColor color);
-                void markerSizeChanged();
+                void borderColorChanged(QColor color);
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
                 friend class ScatterChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterchart/scatterchartitem.cpp 0 -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 "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
                 XYChart(series,presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_items(this),
                 m_visible(true),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
-                QObject::connect(m_series, SIGNAL(markerShapeChanged()), this, SLOT(handleUpdated()));
-                QObject::connect(m_series, SIGNAL(markerSizeChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                         case QScatterSeries::MarkerShapeCircle: {
                             QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                             const QRectF& rect = i->boundingRect();
                             i->setPos(-rect.width()/2,-rect.height()/2);
                             item = new Marker(i,this);
                             break;
                         }
                         case QScatterSeries::MarkerShapeRectangle: {
                             QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                             i->setPos(-m_size/2,-m_size/2);
                             item = new Marker(i,this);
                             break;
                         }
                         default:
                         qWarning()<<"Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker *marker)
             {
                 emit XYChart::clicked(calculateDomainPoint(marker->point()));
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setPoint(point);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!m_visible || !clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 setPos(origin());
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setBrush(brush);
                 }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_visible != m_series->isVisible()
                         || m_size != m_series->markerSize()
                         || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 if(recreate) {
                     // TODO: optimize handleUpdate to recreate points only in case shape changed
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             void ScatterChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +22 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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.
             */
             /*!
                \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()
             */
             /*!
+                \property QXYSeries::color
+                Line (pen) color of the series. This is a convenience property for modifying the color of pen.
+                \sa QXYSeries::pen()
+            */
+            /*!
                 \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)
+                \fn void QXYSeries::colorChanged(QColor color)
-                \brief Signal is emitted when the point visibility has changed to \a visible.
+                \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \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::setColor(const QColor &color)
+            {
+                QPen p = pen();
+                if (p.color() != color) {
+                    p.setColor(color);
+                    setPen(p);
+                    emit colorChanged(color);
+                }
+            }
+            QColor QXYSeries::color() const
+            {
+                return pen().color();
+            }
             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 +6 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef 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 NOTIFY pointsVisibleChanged)
+                Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
+                Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             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;
+                virtual void setColor(const QColor &color);
+                virtual QColor color() 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);
+                void colorChanged(QColor color);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

tests/qmlchartproperties/qml/qmlchartproperties/AreaEditor.qml +5 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
+                    if (series && series.name == "area 1") {
                         seriesConnections.target = series;
+                    } else {
+                        seriesConnections.target = null;
+                    }
                 }
                 Connections {
                     id: seriesConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onNameChanged:              console.log("series.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
                     onColorChanged:             console.log("series.onColorChanged: " + series.color);
                     onBorderColorChanged:       console.log("series.onBorderColorChanged: " + series.borderColor);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: "upper color"
                     onClicked: series.upperSeries.color = main.nextColor();
                 }
                 Button {
                     text: "lower color"
                     onClicked: series.lowerSeries.color = main.nextColor();
                 }
                 Button {
                     text: "upper points visible"
                     onClicked: series.upperSeries.pointsVisible = !series.pointsVisible;
                 }
                 Button {
                     text: "lower points visible"
                     onClicked: series.lowerSeries.pointsVisible = !series.pointsVisible;
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 axisXLabels: ["0", "2007", "1", "2008", "2", "2009", "3", "2010", "4", "2011", "5", "2012"]
                 property variant series: daSeries
                 BarSeries {
                     id: daSeries
+                    name: "bar"
                     BarSet { label: "Bob"; values: [4, 7, 3, 10, 5, 6] }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 8] }
                     BarSet { label: "James"; values: [3, 5, 8, 5, 4, 7] }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarEditor.qml +7 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
+                    if (series && series.name == "bar") {
                         seriesConnections.target = series;
                         setConnections.target = series.at(0);
+                    } else {
+                        seriesConnections.target = null;
+                        setConnections.target = null;
+                    }
                 }
                 Connections {
                     id: seriesConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     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: " + count);
                 }
                 Connections {
                     id: setConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onColorChanged:             console.log("series.onColorChanged: " + color);
                     onBorderColorChanged:       console.log("series.onBorderColorChanged: " + color);
                     onLabelColorChanged:        console.log("series.onLabelColorChanged: " + color);
                     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 +12 -15

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             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: {
+                    if (series && series.name == "") {
+                        chartConnections.target = series;
                         legendConnections.target = series.legend;
                         axisXConnections.target = series.axisX;
                         axisYConnections.target = series.axisY;
+                    } else {
+                        legendConnections.target = null;
+                        axisXConnections.target = null;
+                        axisYConnections.target = null;
+                    }
                 }
                 Connections {
-                    target: series
+                    id: chartConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     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
+                    target: null
-                    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
+                    target: null
                     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);
                     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
+                    target: null
                     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);
                     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 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 X nice nmb"
                     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;
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/GroupedBarChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Grouped bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 axisXLabels: ["0", "2007", "1", "2008", "2", "2009", "3", "2010", "4", "2011", "5", "2012"]
                 property variant series: daSeries
                 GroupedBarSeries {
                     id: daSeries
+                    name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/LineEditor.qml +5 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
+                    if (series && (series.name == "line 1" || series.name == "spline 1")) {
                         seriesConnections.target = series;
+                    } else {
+                        seriesConnections.target = null;
+                    }
                 }
                 Connections {
                     id: seriesConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onNameChanged:              console.log("series.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
-                    onPointsVisibleChanged:     console.log("series.onPointsVisibleChanged: " + series.pointsVisible);
                     onColorChanged:             console.log("series.onColorChanged: " + series.color);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "points visible"
                     onClicked: series.pointsVisible = !series.pointsVisible
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Percent bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 axisXLabels: ["0", "2007", "1", "2008", "2", "2009", "3", "2010", "4", "2011", "5", "2012"]
                 property variant series: daSeries
                 PercentBarSeries {
                     id: daSeries
+                    name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PieChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 id: chart
                 title: "pie series"
                 animationOptions: ChartView.SeriesAnimations
                 property variant series: pieSeries
                 PieSeries {
                     id: pieSeries
+                    name: "pie"
                     PieSlice { id: daSlice; label: "slice1"; value: 11 }
                     PieSlice { label: "slice2"; value: 22 }
                     PieSlice { label: "slice3"; value: 33 }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PieEditor.qml +7 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
+                    if (series && series.name == "pie") {
                         seriesConnections.target = series;
                         sliceConnections.target = series.at(0);
+                    } else {
+                        seriesConnections.target = null;
+                        sliceConnections.target = null;
+                    }
                 }
                 Connections {
                     id: seriesConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
                     onHorizontalPositionChanged:console.log("series.onHorizontalPositionChanged: " + series.horizontalPosition);
                     onVerticalPositionChanged:  console.log("series.onVerticalPositionChanged: " + series.verticalPosition);
                     onSizeChanged:              console.log("series.onSizeChanged: " + series.size);
                     onStartAngleChanged:        console.log("series.onStartAngleChanged: " + series.startAngle);
                     onEndAngleChanged:          console.log("series.onEndAngleChanged: " + series.endAngle);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
                     onSumChanged:               console.log("series.onSumChanged: " + series.sum);
                 }
                 Connections {
                     id: sliceConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onValueChanged:             console.log("slice.onValueChanged: " + series.at(0).value);
                     onLabelVisibleChanged:      console.log("slice.onLabelVisibleChanged: " + series.at(0).labelVisible);
                     onLabelPositionChanged:     console.log("slice.onLabelPositionChanged: " + series.at(0).labelPosition);
                     onExplodedChanged:          console.log("slice.onExplodedChanged: " + series.at(0).exploded);
                     onPenChanged:               console.log("slice.onPenChanged: " + series.at(0).pen);
                     onBorderColorChanged:       console.log("slice.onBorderColorChanged: " + series.at(0).borderColor);
                     onBorderWidthChanged:       console.log("slice.onBorderWidthChanged: " + series.at(0).borderWidth);
                     onBrushChanged:             console.log("slice.onBrushChanged: " + series.at(0).brush);
                     onColorChanged:             console.log("slice.onColorChanged: " + series.at(0).color);
                     onLabelColorChanged:        console.log("slice.onLabelColorChanged: " + series.at(0).labelColor);
                     onLabelBrushChanged:        console.log("slice.onLabelBrushChanged: " + series.at(0).labelBrush);
                     onLabelFontChanged:         console.log("slice.onLabelFontChanged: " + series.at(0).labelFont);
                     onLabelArmLengthFactorChanged:  console.log("slice.onLabelArmLengthFactorChanged: " + series.at(0).labelArmLengthFactor);
                     onExplodeDistanceFactorChanged: console.log("slice.onExplodeDistanceFactorChanged: " + series.at(0).explodeDistanceFactor);
                     onPercentageChanged:        console.log("slice.onPercentageChanged: " + series.at(0).percentage);
                     onStartAngleChanged:        console.log("slice.onStartAngleChanged: " + series.at(0).startAngle);
                     onAngleSpanChanged:         console.log("slice.onAngleSpanChanged: " + series.at(0).angleSpan);
                     onClicked:                  console.log("slice.onClicked");
                     onHovered:                  console.log("slice.onHovered: " + state);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "series hpos +"
                     onClicked: series.horizontalPosition += 0.1;
                 }
                 Button {
                     text: "series hpos -"
                     onClicked: series.horizontalPosition -= 0.1;
                 }
                 Button {
                     text: "series vpos +"
                     onClicked: series.verticalPosition += 0.1;
                 }
                 Button {
                     text: "series vpos -"
                     onClicked: series.verticalPosition -= 0.1;
                 }
                 Button {
                     text: "series size +"
                     onClicked: series.size += 0.1;
                 }
                 Button {
                     text: "series size -"
                     onClicked: series.size -= 0.1;
                 }
                 Button {
                     text: "series start angle +"
                     onClicked: series.startAngle += 1.1;
                 }
                 Button {
                     text: "series start angle -"
                     onClicked: series.startAngle -= 1.1;
                 }
                 Button {
                     text: "series end angle +"
                     onClicked: series.endAngle += 1.1;
                 }
                 Button {
                     text: "series end angle -"
                     onClicked: series.endAngle -= 1.1;
                 }
                 Button {
                     text: "slice color"
                     onClicked: series.at(0).color = main.nextColor();
                 }
                 Button {
                     text: "slice border color"
                     onClicked: series.at(0).borderColor = main.nextColor();
                 }
                 Button {
                     text: "slice border width +"
                     onClicked: series.at(0).borderWidth++;
                 }
                 Button {
                     text: "slice border width -"
                     onClicked: series.at(0).borderWidth--;
                 }
                 Button {
                     text: "slice label visible"
                     onClicked: series.at(0).labelVisible = !series.at(0).labelVisible;
                 }
                 Button {
                     text: "slice label position inside"
                     onClicked: series.at(0).labelPosition = PieSlice.LabelInside;
                 }
                 Button {
                     text: "slice label position outside"
                     onClicked: series.at(0).labelPosition = PieSlice.LabelOutside;
                 }
                 Button {
                     text: "slice label arm len +"
                     onClicked: series.at(0).labelArmLengthFactor += 0.1;
                 }
                 Button {
                     text: "slice label arm len -"
                     onClicked: series.at(0).labelArmLengthFactor -= 0.1;
                 }
                 Button {
                     text: "slice label color"
                     onClicked: series.at(0).labelColor = main.nextColor();
                 }
                 Button {
                     text: "slice exploded"
                     onClicked: series.at(0).exploded = !series.at(0).exploded;
                 }
                 Button {
                     text: "slice explode dist +"
                     onClicked: series.at(0).explodeDistanceFactor += 0.1;
                 }
                 Button {
                     text: "slice explode dist -"
                     onClicked: series.at(0).explodeDistanceFactor -= 0.1;
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ScatterEditor.qml +5 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
+                    if (series && series.name == "scatter 1") {
                         seriesConnections.target = series;
+                    } else {
+                        seriesConnections.target = null;
+                    }
                 }
                 Connections {
                     id: seriesConnections
-                    ignoreUnknownSignals: true
+                    target: null
                     onNameChanged:              console.log("series.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
-                    onPointsVisibleChanged:     console.log("series.onPointsVisibleChanged: " + series.pointsVisible);
                     onColorChanged:             console.log("series.onColorChanged: " + series.color);
                     onBorderColorChanged:       console.log("series.onBorderColorChanged: " + series.borderColor);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
-                    onMarkerSizeChanged:        console.log("series.onMarkerSizeChanged: " + series.markerSize);
-                    onMarkerShapeChanged:       console.log("series.onMarkerShapeChanged: " + series.markerShape);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: "markerSize +"
                     onClicked: series.markerSize += 1.0;
                 }
                 Button {
                     text: "markerSize -"
                     onClicked: series.markerSize -= 1.0;
                 }
                 Button {
                     text: "markerShape"
                     onClicked: series.markerShape = ((series.markerShape + 1) % 2);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Stacked bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 axisXLabels: ["0", "2007", "1", "2008", "2", "2009", "3", "2010", "4", "2011", "5", "2012"]
                 property variant series: daSeries
                 StackedBarSeries {
                     id: daSeries
+                    name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                 }
             }

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