HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2101:3e6adf48dbd5

coding style fixes for plugins

Jani Honkonen -

r2101:3e6adf48dbd5

parent child

Context file:

r2101:3e6adf48dbd5

Collapse all files

plugins/declarative/declarativeareaseries.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativeareaseries.h"
             #include "declarativelineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeAreaSeries::DeclarativeAreaSeries(QObject *parent) :
                 QAreaSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
-            void DeclarativeAreaSeries::setUpperSeries(DeclarativeLineSeries* series)
+            void DeclarativeAreaSeries::setUpperSeries(DeclarativeLineSeries *series)
             {
                 QAreaSeries::setUpperSeries(series);
             }
-            DeclarativeLineSeries* DeclarativeAreaSeries::upperSeries() const
+            DeclarativeLineSeries *DeclarativeAreaSeries::upperSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::upperSeries());
             }
-            void DeclarativeAreaSeries::setLowerSeries(DeclarativeLineSeries* series)
+            void DeclarativeAreaSeries::setLowerSeries(DeclarativeLineSeries *series)
             {
                 QAreaSeries::setLowerSeries(series);
             }
-            DeclarativeLineSeries* DeclarativeAreaSeries::lowerSeries() const
+            DeclarativeLineSeries *DeclarativeAreaSeries::lowerSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::lowerSeries());
             }
             qreal DeclarativeAreaSeries::borderWidth() const
             {
                 return pen().widthF();
             }
             void DeclarativeAreaSeries::setBorderWidth(qreal width)
             {
                 if (width != pen().widthF()) {
                     QPen p = pen();
                     p.setWidthF(width);
                     setPen(p);
                     emit borderWidthChanged(width);
                 }
             }
             #include "moc_declarativeareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativeareaseries.h +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEAREASERIES_H
             #define DECLARATIVEAREASERIES_H
             #include "qareaseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeLineSeries;
             class DeclarativeAreaSeries : public QAreaSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(DeclarativeLineSeries *upperSeries READ upperSeries WRITE setUpperSeries)
                 Q_PROPERTY(DeclarativeLineSeries *lowerSeries READ lowerSeries WRITE setLowerSeries)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(qreal borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged REVISION 1)
             public:
                 explicit DeclarativeAreaSeries(QObject *parent = 0);
-                void setUpperSeries(DeclarativeLineSeries* series);
+                void setUpperSeries(DeclarativeLineSeries *series);
-                DeclarativeLineSeries* upperSeries() const;
+                DeclarativeLineSeries *upperSeries() const;
-                void setLowerSeries(DeclarativeLineSeries* series);
+                void setLowerSeries(DeclarativeLineSeries *series);
-                DeclarativeLineSeries* lowerSeries() const;
+                DeclarativeLineSeries *lowerSeries() const;
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 qreal borderWidth() const;
                 void setBorderWidth(qreal borderWidth);
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void borderWidthChanged(qreal width);
             private:
                 QAbstractAxis *m_axisX;
                 QAbstractAxis *m_axisY;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEAREASERIES_H

plugins/declarative/declarativebarseries.cpp +20 -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 "declarativebarseries.h"
             #include "qbarset.h"
             #include "qvbarmodelmapper.h"
             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            DeclarativeBarSet::DeclarativeBarSet(QObject *parent) :
+            DeclarativeBarSet::DeclarativeBarSet(QObject *parent)
-                QBarSet("", parent)
+                : QBarSet("", parent)
             {
                 connect(this, SIGNAL(valuesAdded(int,int)), this, SLOT(handleCountChanged(int,int)));
                 connect(this, SIGNAL(valuesRemoved(int,int)), this, SLOT(handleCountChanged(int,int)));
             }
             void DeclarativeBarSet::handleCountChanged(int index, int count)
             {
                 Q_UNUSED(index)
                 Q_UNUSED(count)
                 emit countChanged(QBarSet::count());
             }
             qreal DeclarativeBarSet::borderWidth() const
             {
                 return pen().widthF();
             }
             void DeclarativeBarSet::setBorderWidth(qreal width)
             {
                 if (width != pen().widthF()) {
                     QPen p = pen();
                     p.setWidthF(width);
                     setPen(p);
                     emit borderWidthChanged(width);
                 }
             }
             QVariantList DeclarativeBarSet::values()
             {
                 QVariantList values;
                 for (int i(0); i < count(); i++)
                     values.append(QVariant(QBarSet::at(i)));
                 return values;
             }
             void DeclarativeBarSet::setValues(QVariantList values)
             {
                 while (count())
                     remove(count() - 1);
                 for (int i(0); i < values.count(); i++) {
                     if (values.at(i).canConvert(QVariant::Double))
                         QBarSet::append(values[i].toDouble());
                 }
             }
             // Declarative bar series ======================================================================================
             DeclarativeBarSeries::DeclarativeBarSeries(QDeclarativeItem *parent) :
                 QBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativeBarSeries::classBegin()
             {
             }
             void DeclarativeBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             // Declarative stacked bar series ==============================================================================
             DeclarativeStackedBarSeries::DeclarativeStackedBarSeries(QDeclarativeItem *parent) :
                 QStackedBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativeStackedBarSeries::classBegin()
             {
             }
             void DeclarativeStackedBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeStackedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeStackedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeStackedBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeStackedBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QStackedBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             // Declarative percent bar series ==============================================================================
             DeclarativePercentBarSeries::DeclarativePercentBarSeries(QDeclarativeItem *parent) :
                 QPercentBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativePercentBarSeries::classBegin()
             {
             }
             void DeclarativePercentBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativePercentBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativePercentBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativePercentBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativePercentBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QPercentBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             // Declarative horizontal bar series ===========================================================================
             DeclarativeHorizontalBarSeries::DeclarativeHorizontalBarSeries(QDeclarativeItem *parent) :
                 QHorizontalBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativeHorizontalBarSeries::classBegin()
             {
             }
             void DeclarativeHorizontalBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeHorizontalBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeHorizontalBarSeries::appendSeriesChildren);
             }
             void DeclarativeHorizontalBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeHorizontalBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeHorizontalBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QHorizontalBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             // Declarative horizontal stacked bar series ===================================================================
             DeclarativeHorizontalStackedBarSeries::DeclarativeHorizontalStackedBarSeries(QDeclarativeItem *parent) :
                 QHorizontalStackedBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativeHorizontalStackedBarSeries::classBegin()
             {
             }
             void DeclarativeHorizontalStackedBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeHorizontalStackedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeHorizontalStackedBarSeries::appendSeriesChildren);
             }
             void DeclarativeHorizontalStackedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeHorizontalStackedBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeHorizontalStackedBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QHorizontalStackedBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             // Declarative horizontal percent bar series ===================================================================
             DeclarativeHorizontalPercentBarSeries::DeclarativeHorizontalPercentBarSeries(QDeclarativeItem *parent) :
                 QHorizontalPercentBarSeries(parent),
                 m_axisX(0),
                 m_axisY(0)
             {
             }
             void DeclarativeHorizontalPercentBarSeries::classBegin()
             {
             }
             void DeclarativeHorizontalPercentBarSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
                         QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
-                    } else if(qobject_cast<QVBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHBarModelMapper *>(child)) {
+                    } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeHorizontalPercentBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeHorizontalPercentBarSeries::appendSeriesChildren);
             }
             void DeclarativeHorizontalPercentBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeHorizontalPercentBarSeries::at(int index)
             {
-                QList<QBarSet*> setList = barSets();
+                QList<QBarSet *> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeHorizontalPercentBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QHorizontalPercentBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             #include "moc_declarativebarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativebarseries.h +12 -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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEBARSERIES_H
             #define DECLARATIVEBARSERIES_H
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qhorizontalbarseries.h"
             #include "qhorizontalstackedbarseries.h"
             #include "qhorizontalpercentbarseries.h"
             #include "qbarset.h"
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/QDeclarativeItem>
                 #include <QtQuick1/QDeclarativeParserStatus>
             #else
                 #include <QtDeclarative/QDeclarativeItem>
                 #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class DeclarativeBarSet : public QBarSet
             {
                 Q_OBJECT
                 Q_PROPERTY(QVariantList values READ values WRITE setValues)
                 Q_PROPERTY(qreal borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged REVISION 1)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
             public:
                 explicit DeclarativeBarSet(QObject *parent = 0);
                 QVariantList values();
                 void setValues(QVariantList values);
                 qreal borderWidth() const;
                 void setBorderWidth(qreal borderWidth);
             public: // From QBarSet
                 Q_INVOKABLE void append(qreal value) { QBarSet::append(value); }
                 Q_INVOKABLE void remove(const int index, const int count = 1) { QBarSet::remove(index, count); }
                 Q_INVOKABLE void replace(int index, qreal value) { QBarSet::replace(index, value); }
                 Q_INVOKABLE qreal at(int index) { return QBarSet::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
                 Q_REVISION(1) void borderWidthChanged(qreal width);
             private Q_SLOTS:
                 void handleCountChanged(int index, int count);
             };
             class DeclarativeBarSeries : public QBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             class DeclarativeStackedBarSeries : public QStackedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeStackedBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QStackedBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QStackedBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             class DeclarativePercentBarSeries : public QPercentBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativePercentBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QPercentBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QPercentBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             class DeclarativeHorizontalBarSeries : public QHorizontalBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeHorizontalBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QHorizontalBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QHorizontalBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             class DeclarativeHorizontalStackedBarSeries : public QHorizontalStackedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeHorizontalStackedBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QHorizontalStackedBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QHorizontalStackedBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             class DeclarativeHorizontalPercentBarSeries : public QHorizontalPercentBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeHorizontalPercentBarSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axisX; }
                 void setAxisX(QAbstractAxis *axis) { m_axisX = axis; emit axisXChanged(axis); }
                 QAbstractAxis *axisY() { return m_axisY; }
                 void setAxisY(QAbstractAxis *axis) { m_axisY = axis; emit axisYChanged(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBarSet *barset) { return QHorizontalPercentBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QHorizontalPercentBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
-                QAbstractAxis* m_axisX;
+                QAbstractAxis *m_axisX;
-                QAbstractAxis* m_axisY;
+                QAbstractAxis *m_axisY;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEBARSERIES_H

plugins/declarative/declarativecategoryaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativecategoryaxis.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass CategoryRange
                 \brief With CategoryRange you can define a range used by a CategoryAxis.
                 \sa CategoryAxis
             */
             DeclarativeCategoryRange::DeclarativeCategoryRange(QObject *parent) :
                 QObject(parent),
                 m_endValue(0),
                 m_label(QString())
             {
             }
             DeclarativeCategoryAxis::DeclarativeCategoryAxis(QObject *parent) :
                 QCategoryAxis(parent)
             {
             }
             void DeclarativeCategoryAxis::classBegin()
             {
             }
             void DeclarativeCategoryAxis::componentComplete()
             {
                 QList<QPair<QString, qreal> > ranges;
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeCategoryRange *>(child)) {
                         DeclarativeCategoryRange *range = qobject_cast<DeclarativeCategoryRange *>(child);
                         ranges.append(QPair<QString, qreal>(range->label(), range->endValue()));
                     }
                 }
                 // Sort and append the range objects according to end value
                 qSort(ranges.begin(), ranges.end(), endValueLessThan);
                 for (int i(0); i < ranges.count(); i++)
                     append(ranges.at(i).first, ranges.at(i).second);
             }
             bool DeclarativeCategoryAxis::endValueLessThan(const QPair<QString, qreal> &value1, const QPair<QString, qreal> &value2)
             {
                 return value1.second < value2.second;
             }
             QDeclarativeListProperty<QObject> DeclarativeCategoryAxis::axisChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeCategoryAxis::appendAxisChildren);
             }
             void DeclarativeCategoryAxis::append(const QString &label, qreal categoryEndValue)
             {
                 QCategoryAxis::append(label, categoryEndValue);
             }
             void DeclarativeCategoryAxis::remove(const QString &label)
             {
                 QCategoryAxis::remove(label);
             }
-            void DeclarativeCategoryAxis::replace(const QString& oldLabel, const QString& newLabel)
+            void DeclarativeCategoryAxis::replace(const QString &oldLabel, const QString &newLabel)
             {
                 QCategoryAxis::replaceLabel(oldLabel, newLabel);
             }
             void DeclarativeCategoryAxis::appendAxisChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list)
                 Q_UNUSED(element)
             }
             #include "moc_declarativecategoryaxis.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativecategoryaxis.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVECATEGORYAXIS_H
             #define DECLARATIVECATEGORYAXIS_H
             #include "qcategoryaxis.h"
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/QDeclarativeListProperty>
                 #include <QtQuick1/QDeclarativeParserStatus>
             #else
                 #include <QtDeclarative/QDeclarativeListProperty>
                 #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeCategoryRange : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal endValue READ endValue WRITE setEndValue)
                 Q_PROPERTY(QString label READ label WRITE setLabel)
             public:
                 explicit DeclarativeCategoryRange(QObject *parent = 0);
                 qreal endValue() { return m_endValue; }
                 void setEndValue(qreal endValue) { m_endValue = endValue; }
                 QString label() { return m_label; }
                 void setLabel(QString label) { m_label = label; }
             private:
                 qreal m_endValue;
                 QString m_label;
             };
             class DeclarativeCategoryAxis : public QCategoryAxis, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> axisChildren READ axisChildren)
                 Q_CLASSINFO("DefaultProperty", "axisChildren")
             public:
                 explicit DeclarativeCategoryAxis(QObject *parent = 0);
                 QDeclarativeListProperty<QObject> axisChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 Q_INVOKABLE void append(const QString &label, qreal categoryEndValue);
                 Q_INVOKABLE void remove(const QString &label);
-                Q_INVOKABLE void replace(const QString& oldLabel, const QString& newLabel);
+                Q_INVOKABLE void replace(const QString &oldLabel, const QString &newLabel);
                 static void appendAxisChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             private:
                 static bool endValueLessThan(const QPair<QString, qreal> &value1, const QPair<QString, qreal> &value2);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECATEGORYAXIS_H

plugins/declarative/declarativechart.cpp +6 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QPainter>
             #include <QDeclarativeEngine>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis.h"
             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "declarativemargins.h"
             #include "qchart_p.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             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 chart with one pie series:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.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 Font ChartView::titleFont
               The title font of the chart
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \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.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               Deprecated. Use minimumMargins and plotArea instead.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               Deprecated. Use minimumMargins and plotArea instead.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               Deprecated. Use minimumMargins and plotArea instead.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               Deprecated. Use minimumMargins and plotArea instead.
             */
             /*!
               \qmlproperty Margins ChartView::minimumMargins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend. Please note that setting the
               properties of minimumMargins may be bigger than the defined value, depending on other ChartView
               properties that affect it's layout. If you need to know the actual plotting area used at any
               given time, you can check ChartView::plotArea instead.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::minimumMargins
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValueAxis::min, ValueAxis::max, BarCategoryAxis::min, BarCategoryAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValueAxis::min, ValueAxis::max, BarCategoryAxis::min, BarCategoryAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValueAxis::min, ValueAxis::max, BarCategoryAxis::min, BarCategoryAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValueAxis::min, ValueAxis::max, BarCategoryAxis::min, BarCategoryAxis::max
             */
             /*!
               \qmlsignal ChartView::onPlotAreaChanged(rect plotArea)
               The plot area of the chart has changed. This may happen for example, if you modify minimumMargins
               or if you resize the chart, or if you modify font size related properties of the legend or chart
               title.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int, int, int, int)), this, SLOT(changeMinimumMargins(int, int, int, int)));
                 connect(m_margins, SIGNAL(bottomChanged(int, int, int, int)), this, SLOT(changeMinimumMargins(int, int, int, int)));
                 connect(m_margins, SIGNAL(leftChanged(int, int, int, int)), this, SLOT(changeMinimumMargins(int, int, int, int)));
                 connect(m_margins, SIGNAL(rightChanged(int, int, int, int)), this, SLOT(changeMinimumMargins(int, int, int, int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)), this, SLOT(handleSeriesAdded(QAbstractSeries *, Domain *)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)), this, SIGNAL(seriesRemoved(QAbstractSeries *)));
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit minimumMarginsChanged();
                 emit plotAreaChanged(m_chart->plotArea());
             }
             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)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Set optional user defined axes for the series and connect axis related signals
                         if (qobject_cast<DeclarativeLineSeries *>(child)) {
                             DeclarativeLineSeries *s = qobject_cast<DeclarativeLineSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeSplineSeries *>(child)) {
                             DeclarativeSplineSeries *s = qobject_cast<DeclarativeSplineSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeScatterSeries *>(child)) {
                             DeclarativeScatterSeries *s = qobject_cast<DeclarativeScatterSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeAreaSeries *>(child)) {
                             DeclarativeAreaSeries *s = qobject_cast<DeclarativeAreaSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeBarSeries *>(child)) {
                             DeclarativeBarSeries *s = qobject_cast<DeclarativeBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeStackedBarSeries *>(child)) {
                             DeclarativeStackedBarSeries *s = qobject_cast<DeclarativeStackedBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativePercentBarSeries *>(child)) {
                             DeclarativePercentBarSeries *s = qobject_cast<DeclarativePercentBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeHorizontalBarSeries *>(child)) {
                             DeclarativeHorizontalBarSeries *s = qobject_cast<DeclarativeHorizontalBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(child)) {
                             DeclarativeHorizontalStackedBarSeries *s = qobject_cast<DeclarativeHorizontalStackedBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         } else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(child)) {
                             DeclarativeHorizontalPercentBarSeries *s = qobject_cast<DeclarativeHorizontalPercentBarSeries *>(child);
                             connect(s, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(s, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             setAxisX(s->axisX(), s);
                             setAxisY(s->axisY(), s);
                         }
                     }
                 }
                 // Create the missing axes for the series that cannot be painted without axes
                 foreach (QAbstractSeries *chartSeries, m_chart->series())
                     createDefaultAxes(chartSeries);
                 QDeclarativeItem::componentComplete();
             }
-            void DeclarativeChart::handleAxisXSet(QAbstractAxis* axis)
+            void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
             //    qDebug() << "DeclarativeChart::handleAxisXSet" << sender() << axis;
                 if (axis && qobject_cast<QAbstractSeries *>(sender()))
                     m_chart->setAxisX(axis, qobject_cast<QAbstractSeries *>(sender()));
                 else
                     qWarning() << "Trying to set axisX to null.";
             }
-            void DeclarativeChart::handleAxisYSet(QAbstractAxis* axis)
+            void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
             //    qDebug() << "DeclarativeChart::handleAxisYSet" << sender() << axis;
                 if (axis && qobject_cast<QAbstractSeries *>(sender()))
                     m_chart->setAxisY(axis, qobject_cast<QAbstractSeries *>(sender()));
                 else
                     qWarning() << "Trying to set axisY to null.";
             }
             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);
                 // It would be better to trigger the plotAreaChanged signal from QChart::plotAreaChanged or
                 // similar. Since that kind of a signal is not clearly needed in the C++ API the work-around is
                 // to implement it here for the QML API purposes.
                 emit plotAreaChanged(m_chart->plotArea());
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             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())
                     m_chart->setAnimationOptions(animationOptions);
             }
             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())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 return m_chart->axisX(series);
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
-            void DeclarativeChart::setTitleFont(const QFont& font)
+            void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             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();
             }
             qreal DeclarativeChart::topMargin()
             {
                 qWarning() << "ChartView.topMargin is deprecated. Use minimumMargins and plotArea instead.";
                 return m_chart->plotArea().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 qWarning() << "ChartView.bottomMargin is deprecated. Use minimumMargins and plotArea instead.";
                 return m_chart->plotArea().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 qWarning() << "ChartView.leftMargin is deprecated. Use minimumMargins and plotArea instead.";
                 return m_chart->plotArea().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 qWarning() << "ChartView.rightMargin is deprecated. Use minimumMargins and plotArea instead.";
                 return m_chart->plotArea().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(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)
             {
                 return createSeries(type, name, 0, 0);
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     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";
                 }
                 if (series) {
                     series->setName(name);
                     m_chart->addSeries(series);
                     // Set possible user defined axes
                     setAxisX(axisX, series);
                     setAxisY(axisY, series);
                     // Then create the missing axes
                     createDefaultAxes(series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis)
                     m_chart->setAxisX(axis, series);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis)
                     m_chart->setAxisY(axis, series);
             }
             void DeclarativeChart::createDefaultAxes()
             {
                 qWarning() << "ChartView.createDefaultAxes() is deprecated. Axes are created automatically.";
             }
-            void DeclarativeChart::createDefaultAxes(QAbstractSeries* series)
+            void DeclarativeChart::createDefaultAxes(QAbstractSeries *series)
             {
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     // If there is already an x axis of the correct type, re-use it
                     if (!m_chart->axisX(series) && s != series && m_chart->axisX(s)
-                            && m_chart->axisX(s)->type() == series->d_ptr->defaultAxisType(Qt::Horizontal))
+                        && m_chart->axisX(s)->type() == series->d_ptr->defaultAxisType(Qt::Horizontal))
                         m_chart->setAxisX(m_chart->axisX(s), series);
                     // If there is already a y axis of the correct type, re-use it
                     if (!m_chart->axisY(series) && s != series && m_chart->axisY(s)
-                            && m_chart->axisY(s)->type() == series->d_ptr->defaultAxisType(Qt::Vertical))
+                        && m_chart->axisY(s)->type() == series->d_ptr->defaultAxisType(Qt::Vertical))
                         m_chart->setAxisY(m_chart->axisY(s), series);
                 }
                 // If no x axis of correct type was found, create a new x axis based of default axis type
                 if (!m_chart->axisX(series)) {
                     switch (series->d_ptr->defaultAxisType(Qt::Horizontal)) {
                     case QAbstractAxis::AxisTypeValue:
                         m_chart->setAxisX(new QValueAxis(this), series);
                         break;
                     case QAbstractAxis::AxisTypeBarCategory:
                         m_chart->setAxisX(new QBarCategoryAxis(this), series);
                         break;
                     case QAbstractAxis::AxisTypeCategory:
                         m_chart->setAxisX(new QCategoryAxis(this), series);
                         break;
             #ifndef QT_ON_ARM
                     case QAbstractAxis::AxisTypeDateTime:
                         m_chart->setAxisX(new QDateTimeAxis(this), series);
                         break;
             #endif
                     default:
                         // Do nothing, assume AxisTypeNoAxis
                         break;
                     }
                 }
                 // If no y axis of correct type was found, create a new y axis based of default axis type
                 if (!m_chart->axisY(series)) {
                     switch (series->d_ptr->defaultAxisType(Qt::Vertical)) {
                     case QAbstractAxis::AxisTypeValue:
                         m_chart->setAxisY(new QValueAxis(this), series);
                         break;
                     case QAbstractAxis::AxisTypeBarCategory:
                         m_chart->setAxisY(new QBarCategoryAxis(this), series);
                         break;
                     case QAbstractAxis::AxisTypeCategory:
                         m_chart->setAxisY(new QCategoryAxis(this), series);
                         break;
             #ifndef QT_ON_ARM
                     case QAbstractAxis::AxisTypeDateTime:
                         m_chart->setAxisY(new QDateTimeAxis(this), series);
                         break;
             #endif
                     default:
                         // Do nothing, assume AxisTypeNoAxis
                         break;
                     }
                 }
                 //qDebug() << "axis for series" << series << "x:" << m_chart->axisX(series) << "y:" << m_chart->axisY(series);
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativechart.h +5 -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 DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <QtCore/QtGlobal>
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/QDeclarativeItem>
             #else
                 #include <QtDeclarative/QDeclarativeItem>
             #endif
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeMargins;
             class Domain;
             class DeclarativeChart : public QDeclarativeItem
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QLegend *legend READ legend)
                 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_PROPERTY(qreal topMargin READ topMargin)
                 Q_PROPERTY(qreal bottomMargin READ bottomMargin)
                 Q_PROPERTY(qreal leftMargin READ leftMargin)
                 Q_PROPERTY(qreal rightMargin READ rightMargin)
                 Q_PROPERTY(DeclarativeMargins *minimumMargins READ minimumMargins NOTIFY minimumMarginsChanged REVISION 1)
                 Q_PROPERTY(DeclarativeMargins *margins READ margins NOTIFY marginsChanged REVISION 2)
                 Q_PROPERTY(QRectF plotArea READ plotArea NOTIFY plotAreaChanged REVISION 1)
                 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,
+                    SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             public:
                 DeclarativeChart(QDeclarativeItem *parent = 0);
                 ~DeclarativeChart();
             public: // From QDeclarativeItem/QGraphicsItem
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 QFont titleFont() const;
-                void setTitleFont(const QFont& font);
+                void setTitleFont(const QFont &font);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 qreal topMargin();
                 qreal bottomMargin();
                 qreal leftMargin();
                 qreal rightMargin();
-                void createDefaultAxes(QAbstractSeries* series);
+                void createDefaultAxes(QAbstractSeries *series);
                 //TODO this is depreciated:
                 DeclarativeMargins *minimumMargins() { return m_margins; }
                 Q_REVISION(2) DeclarativeMargins *margins() { return m_margins; }
                 QRectF plotArea() { return m_chart->plotArea(); }
             public:
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(DeclarativeChart::SeriesType type, QString name = "");
                 Q_INVOKABLE QAbstractSeries *createSeries(DeclarativeChart::SeriesType type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY);
                 Q_INVOKABLE void removeSeries(QAbstractSeries *series);
                 Q_INVOKABLE void removeAllSeries() { m_chart->removeAllSeries(); }
                 Q_INVOKABLE void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void createDefaultAxes();
                 Q_INVOKABLE QAbstractAxis *axisX(QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisY(QAbstractSeries *series = 0);
                 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_SIGNALS:
                 void axisLabelsChanged();
                 void titleColorChanged(QColor color);
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
                 void minimumMarginsChanged();
                 Q_REVISION(2) void marginsChanged();
                 void plotAreaChanged(QRectF plotArea);
-                void seriesAdded(QAbstractSeries* series);
+                void seriesAdded(QAbstractSeries *series);
-                void seriesRemoved(QAbstractSeries* series);
+                void seriesRemoved(QAbstractSeries *series);
             public Q_SLOTS:
                 void changeMinimumMargins(int top, int bottom, int left, int right);
                 void handleAxisXSet(QAbstractAxis *axis);
                 void handleAxisYSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
             private:
                 // 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;
                 //QMargins m_chartMargins;
                 DeclarativeMargins *m_margins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECHART_H

plugins/declarative/declarativepieseries.cpp +7 -7

             /****************************************************************************
             **
             ** 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 "declarativepieseries.h"
             #include "qpieslice.h"
             #include "qvpiemodelmapper.h"
             #include "qhpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativePieSeries::DeclarativePieSeries(QDeclarativeItem *parent) :
                 QPieSeries(parent)
             {
                 connect(this, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleAdded(QList<QPieSlice*>)));
                 connect(this, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleRemoved(QList<QPieSlice*>)));
             }
             void DeclarativePieSeries::classBegin()
             {
             }
             void DeclarativePieSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<QPieSlice *>(child)) {
                         QPieSeries::append(qobject_cast<QPieSlice *>(child));
-                    } else if(qobject_cast<QVPieModelMapper *>(child)) {
+                    } else if (qobject_cast<QVPieModelMapper *>(child)) {
                         QVPieModelMapper *mapper = qobject_cast<QVPieModelMapper *>(child);
                         mapper->setSeries(this);
-                    } else if(qobject_cast<QHPieModelMapper *>(child)) {
+                    } else if (qobject_cast<QHPieModelMapper *>(child)) {
                         QHPieModelMapper *mapper = qobject_cast<QHPieModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativePieSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativePieSeries::appendSeriesChildren);
             }
             void DeclarativePieSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             QPieSlice *DeclarativePieSeries::at(int index)
             {
-                QList<QPieSlice*> sliceList = slices();
+                QList<QPieSlice *> sliceList = slices();
                 if (index >= 0 && index < sliceList.count())
                     return sliceList[index];
                 return 0;
             }
-            QPieSlice* DeclarativePieSeries::find(QString label)
+            QPieSlice *DeclarativePieSeries::find(QString label)
             {
                 foreach (QPieSlice *slice, slices()) {
                     if (slice->label() == label)
                         return slice;
                 }
                 return 0;
             }
-            QPieSlice* DeclarativePieSeries::append(QString label, qreal value)
+            QPieSlice *DeclarativePieSeries::append(QString label, qreal value)
             {
                 QPieSlice *slice = new QPieSlice(this);
                 slice->setLabel(label);
                 slice->setValue(value);
                 QPieSeries::append(slice);
                 return slice;
             }
             bool DeclarativePieSeries::remove(QPieSlice *slice)
             {
                 return QPieSeries::remove(slice);
             }
             void DeclarativePieSeries::clear()
             {
                 QPieSeries::clear();
             }
-            void DeclarativePieSeries::handleAdded(QList<QPieSlice*> slices)
+            void DeclarativePieSeries::handleAdded(QList<QPieSlice *> slices)
             {
                 foreach (QPieSlice *slice, slices)
                     emit sliceAdded(slice);
             }
-            void DeclarativePieSeries::handleRemoved(QList<QPieSlice*> slices)
+            void DeclarativePieSeries::handleRemoved(QList<QPieSlice *> slices)
             {
                 foreach (QPieSlice *slice, slices)
                     emit sliceRemoved(slice);
             }
             #include "moc_declarativepieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativepieseries.h +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEPIESERIES_H
             #define DECLARATIVEPIESERIES_H
             #include "qpieseries.h"
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/QDeclarativeItem>
                 #include <QtQuick1/QDeclarativeParserStatus>
             #else
                 #include <QtDeclarative/QDeclarativeItem>
                 #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class DeclarativePieSeries : public QPieSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativePieSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<QObject> seriesChildren();
                 Q_INVOKABLE QPieSlice *at(int index);
                 Q_INVOKABLE QPieSlice *find(QString label);
                 Q_INVOKABLE QPieSlice *append(QString label, qreal value);
                 Q_INVOKABLE bool remove(QPieSlice *slice);
                 Q_INVOKABLE void clear();
             public:
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
-                void sliceAdded(QPieSlice* slice);
+                void sliceAdded(QPieSlice *slice);
-                void sliceRemoved(QPieSlice* slice);
+                void sliceRemoved(QPieSlice *slice);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
-                void handleAdded(QList<QPieSlice*> slices);
+                void handleAdded(QList<QPieSlice *> slices);
-                void handleRemoved(QList<QPieSlice*> slices);
+                void handleRemoved(QList<QPieSlice *> slices);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEPIESERIES_H

plugins/declarative/declarativexyseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativexyseries.h"
             #include "declarativexypoint.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             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)) {
+                    } else if (qobject_cast<QVXYModelMapper *>(child)) {
                         QVXYModelMapper *mapper = qobject_cast<QVXYModelMapper *>(child);
                         mapper->setSeries(series);
-                    } else if(qobject_cast<QHXYModelMapper *>(child)) {
+                    } else if (qobject_cast<QHXYModelMapper *>(child)) {
                         QHXYModelMapper *mapper = qobject_cast<QHXYModelMapper *>(child);
                         mapper->setSeries(series);
                     }
                 }
             }
             void DeclarativeXySeries::append(qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->append(x, y);
             }
             void DeclarativeXySeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->replace(oldX, oldY, newX, newY);
             }
             void DeclarativeXySeries::remove(qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->remove(x, y);
             }
             void DeclarativeXySeries::insert(int index, qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->insert(index, QPointF(x, y));
             }
             void DeclarativeXySeries::clear()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->clear();
             }
             QPointF DeclarativeXySeries::at(int index)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 if (index >= 0 || index < series->count())
                     return series->points().at(index);
                 return QPointF(0, 0);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/plugin.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifdef QT5_QUICK_1
                 #include <QtQuick1/qdeclarativeextensionplugin.h>
                 #include <QtQuick1/qdeclarative.h>
             #else
                 #include <QtDeclarative/qdeclarativeextensionplugin.h>
                 #include <QtDeclarative/qdeclarative.h>
             #endif
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include "declarativemargins.h"
             #include <QAbstractItemModel>
             #ifndef QT_ON_ARM
             #include "qdatetimeaxis.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             #ifdef QT5_QUICK_1
                 // TODO: fix the metadata
                 Q_PLUGIN_METADATA(IID "org.qt-project.foo")
             #endif
-                public:
+            public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     // QtCommercial.Chart 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 1, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 1, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 1, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 1, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 1, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 1, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 1, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 1, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 1, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 1, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 1, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 1, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 1, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 1, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 1, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 1, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 1, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 1, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 1, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCommercial.Chart 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #ifndef QT5_QUICK_1
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

plugins/designer/qchartsplugin.cpp +7 -8

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchartsplugin.h"
             #include "qchartview.h"
             #include <QtPlugin>
             QTCOMMERCIALCHART_USE_NAMESPACE
             QChartsPlugin::QChartsPlugin(QObject *parent) :
                 QObject(parent)
             {
                 // TODO Auto-generated constructor stub
             }
             QChartsPlugin::~QChartsPlugin()
             {
                 // TODO Auto-generated destructor stub
             }
             QString QChartsPlugin::name() const
             {
                 return "QChartView";
             }
             QString QChartsPlugin::includeFile() const
             {
-                #ifdef linux
+            #ifdef linux
                 QString myNewLine = "\n";
-                #endif
+            #endif
-                #ifdef WIN32
+            #ifdef WIN32
                 QString myNewLine = "\n\r";
-                #endif
+            #endif
-                #ifdef __APPLE__
+            #ifdef __APPLE__
                 QString myNewLine = "\n";
-                #endif
+            #endif
                 return "<qchartview.h>" + myNewLine + "#include <chartsnamespace.h>";
             }
             QString QChartsPlugin::group() const
             {
                 return tr("QCharts Widgets");
             }
             QIcon QChartsPlugin::icon() const
             {
                 return QIcon(":/images/qcharts.png");
             }
             QString QChartsPlugin::toolTip() const
             {
                 return tr("An qcharts view widget");
             }
             QString QChartsPlugin::whatsThis() const
             {
                 return tr("This widget is presents QChartView widget");
             }
             bool QChartsPlugin::isContainer() const
             {
                 return false;
             }
-            QWidget* QChartsPlugin::createWidget(QWidget *parent)
+            QWidget *QChartsPlugin::createWidget(QWidget *parent)
             {
                 return new QChartView(new QChart(), parent);
             }
             #ifndef QT5_QUICK_1
                 Q_EXPORT_PLUGIN2(qtcommercialchart, QChartsPlugin)
             #endif

plugins/designer/qchartsplugin.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCHARTSPLUGIN_H
             #define QCHARTSPLUGIN_H
             #include <QDesignerCustomWidgetInterface>
-            class QChartsPlugin: public QObject,public QDesignerCustomWidgetInterface
+            class QChartsPlugin: public QObject, public QDesignerCustomWidgetInterface
             {
             #ifdef QT5_QUICK_1
                 Q_PLUGIN_METADATA(IID "org.qt-project.bar")
             #endif
                 Q_OBJECT
                 Q_INTERFACES(QDesignerCustomWidgetInterface)
             public:
                 QChartsPlugin(QObject *parent = 0);
                 ~QChartsPlugin();
                 QString name() const;
                 QString includeFile() const;
                 QString group() const;
                 QIcon icon() const;
                 QString toolTip() const;
                 QString whatsThis() const;
                 bool isContainer() const;
                 QWidget *createWidget(QWidget *parent);
             };
             #endif /* QCHARTSPLUGIN_H */

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