HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1278:86b61f579398

XY model mappers to QML api

Tero Ahola -

r1278:86b61f579398

parent child

Context file:

r1278:86b61f579398

Collapse all files

demos/qmlchart/qml/qmlchart/View4.qml +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 anchors.fill: parent
                 ChartView {
                     title: "Scatters"
                     anchors.fill: parent
                     theme: ChartView.ChartThemeBlueCerulean
+                    axisX.max: 4
+                    axisY.max: 4
                     ScatterSeries {
                         id: scatter1
                         name: "Scatter1"
                         XyPoint { x: 1.5; y: 1.5 }
                         XyPoint { x: 1.5; y: 1.6 }
                         XyPoint { x: 1.57; y: 1.55 }
                         XyPoint { x: 1.8; y: 1.8 }
                         XyPoint { x: 1.9; y: 1.6 }
                         XyPoint { x: 2.1; y: 1.3 }
                         XyPoint { x: 2.5; y: 2.1 }
                     }
                     ScatterSeries {
                         name: "Scatter2"
                         XyPoint { x: 2.0; y: 2.0 }
                         XyPoint { x: 2.0; y: 2.1 }
                         XyPoint { x: 2.07; y: 2.05 }
                         XyPoint { x: 2.2; y: 2.9 }
                         XyPoint { x: 2.4; y: 2.7 }
                         XyPoint { x: 2.67; y: 2.65 }
                     }
                 }
             }

demos/qmlcustommodel/qml/qmlcustommodel/main.qml +38 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             import QmlCustomModel 1.0
             Rectangle {
                 width: parent.width
                 height: parent.height
                 ChartView {
                     id: chart
                     title: "Custom model example"
                     anchors.fill: parent
                     theme: ChartView.ChartThemeLight
+                    axisX.max: 20
+                    axisY.max: 20
                     // For dynamic data we use a custom data model derived from QAbstractiItemModel
                     CustomModel {
                         id: customModel
-                        CustomModelElement { values: ["Volkswagen", 13.5, 4.4] }
+                        CustomModelElement { values: [index, "Manufacturer", 1, 2] }
-                        CustomModelElement { values: ["Toyota", 10.9, 4.2] }
+                        CustomModelElement { values: [1, "Volkswagen", 13.5, 12.5] }
-                        CustomModelElement { values: ["Ford", 8.6, 3.0] }
+                        CustomModelElement { values: [2, "Toyota", 10.9, 9.9] }
-                        CustomModelElement { values: ["Skoda", 8.2, 1.9] }
+                        CustomModelElement { values: [3, "Ford", 8.6, 7.6] }
-                        CustomModelElement { values: ["Volvo", 6.8, 1.5] }
+                        CustomModelElement { values: [4, "Skoda", 8.2, 7.2] }
+                        CustomModelElement { values: [5, "Volvo", 6.8, 5.8] }
                     }
                     LineSeries {
-                        name: "line"
+                        name: "Volkswagen"
+                        HXYModelMapper {
-                        // TODO: the new mapper api
+                            model: customModel
-            //            VXYModelMapper {
+                            xRow: 0
-            //                model: customModel
+                            yRow: 1
-            //                xColumn: 0
+                            first: 2
-            //                yColumn: 1
-            //            }
                     }
+                    LineSeries {
+                        name: "Toyota"
+                        HXYModelMapper {
+                            model: customModel
+                            xRow: 0
+                            yRow: 2
+                            first: 2
+                        }
+                    }
                     PieSeries {
                         id: pieSeries
                         size: 0.4
                         horizontalPosition: 0.2
                         verticalPosition: 0.3
                     }
                     VPieModelMapper {
                         series: pieSeries
                         model: customModel
-                        labelsColumn: 0
+                        labelsColumn: 1
-                        valuesColumn: 1
+                        valuesColumn: 2
+                        first: 1
                     }
-            //        AreaSeries {
+                    AreaSeries {
-            //            name: "area"
+                        name: "Ford"
-            //            upperSeries: LineSeries {}
+                        upperSeries: LineSeries {
-            //            lowerSeries: LineSeries {}
+                            HXYModelMapper {
-            //        }
+                                model: customModel
+                                xRow: 0
+                                yRow: 3
+                                first: 2
+                            }
+                        }
+                    }
             //        BarSeries {
             //            model: customModel
             //            modelMapper.first: 0
             //        }
                 }
                 // TODO: you could also implement appending to your model, for example:
             //        pieSeries.model.append(["Others", 52.0]);
                 // TODO: show how to use data from a list model in a chart view
                 // i.e. copy the data into a custom model
             //    ListModel {
             //        id: listModel
             //        ListElement {
             //            label: "Volkswagen"
             //            value: 13.5
             //        }
             //        ListElement {
             //            label: "Toyota"
             //            value: 10.9
             //        }
             //        // and so on...
             //    }
             }

plugins/declarative/declarativechart.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 "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this)),
                   m_legend(LegendTop)
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
-                m_chart->axisX()->setNiceNumbersEnabled(false);
+            //    m_chart->axisX()->setNiceNumbersEnabled(false);
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
             //    qDebug() << "DeclarativeChart::componentComplete(), maxX: " << axisX()->max();
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }
                 }
             //    qDebug() << "DeclarativeChart::componentComplete(), maxX: " << axisX()->max();
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 Q_UNUSED(oldGeometry)
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 m_chart->setTheme((QChart::ChartTheme) theme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 m_chart->setAnimationOptions((QChart::AnimationOption) animations);
             }
             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::setLegend(DeclarativeChart::Legend legend)
             {
                 if (legend != m_legend) {
                     m_legend = legend;
                     switch (m_legend) {
                     case LegendDisabled:
                         m_chart->legend()->setVisible(false);
                         break;
                     case LegendTop:
                         m_chart->legend()->setVisible(true);
                         m_chart->legend()->setAlignment(QLegend::AlignmentTop);
                         break;
                     case LegendBottom:
                         m_chart->legend()->setVisible(true);
                         m_chart->legend()->setAlignment(QLegend::AlignmentBottom);
                         break;
                     case LegendLeft:
                         m_chart->legend()->setVisible(true);
                         m_chart->legend()->setAlignment(QLegend::AlignmentLeft);
                         break;
                     case LegendRight:
                         m_chart->legend()->setVisible(true);
                         m_chart->legend()->setAlignment(QLegend::AlignmentRight);
                         break;
                     default:
                         m_chart->legend()->setVisible(false);
                         break;
                     }
                 }
             }
             DeclarativeChart::Legend DeclarativeChart::legend()
             {
                 return m_legend;
             }
             QAxis *DeclarativeChart::axisX()
             {
                 return m_chart->axisX();
             }
             QAxis *DeclarativeChart::axisY()
             {
                 return m_chart->axisY();
             }
             QVariantList DeclarativeChart::axisXLabels()
             {
                 QVariantList labels;
                 foreach (qreal value, m_chart->axisX()->categories()->values()) {
                     labels.append(value);
                     labels.append(m_chart->axisX()->categories()->label(value));
                 }
                 return labels;
             }
             void DeclarativeChart::setAxisXLabels(QVariantList list)
             {
                 QVariant value(QVariant::Invalid);
                 foreach (QVariant element, list) {
                     if (value.isValid() && element.type() == QVariant::String) {
                         m_chart->axisX()->categories()->insert(value.toDouble(), element.toString());
                         value = QVariant(QVariant::Invalid);
                     } else {
                         if (element.canConvert(QVariant::Double))
                             value = element;
                     }
                 }
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypeGroupedBar:
                     series = new DeclarativeGroupedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativelineseries.h +7 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVELINESERIES_H
             #define DECLARATIVELINESERIES_H
             #include "qchartglobal.h"
             #include "qlineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             #include <QDeclarativeListProperty>
+            #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class DeclarativeLineSeries : public QLineSeries, public DeclarativeXySeries
+            class DeclarativeLineSeries : public QLineSeries, public DeclarativeXySeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
+                Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QColor color READ penColor WRITE setPenColor)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeLineSeries(QObject *parent = 0);
                 QDeclarativeListProperty<QObject> declarativeChildren();
+            public: // from QDeclarativeParserStatus
+                void classBegin() { DeclarativeXySeries::classBegin(); }
+                void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public: // from QLineSeries
                 Q_INVOKABLE void append(qreal x, qreal y) { QLineSeries::append(x, y); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { QLineSeries::remove(x, y); }
                 Q_INVOKABLE void clear() { QLineSeries::removeAll(); }
                 Q_INVOKABLE DeclarativeXyPoint *at(int index) { return DeclarativeXySeries::at(index); }
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVELINESERIES_H

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

plugins/declarative/declarativesplineseries.h +7 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVESPLINESERIES_H
             #define DECLARATIVESPLINESERIES_H
             #include "qchartglobal.h"
             #include "qsplineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             #include <QDeclarativeListProperty>
+            #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class DeclarativeSplineSeries : public QSplineSeries, public DeclarativeXySeries
+            class DeclarativeSplineSeries : public QSplineSeries, public DeclarativeXySeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
+                Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QColor color READ penColor WRITE setPenColor)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeSplineSeries(QObject *parent = 0);
                 QDeclarativeListProperty<QObject> declarativeChildren();
+            public: // from QDeclarativeParserStatus
+                void classBegin() { DeclarativeXySeries::classBegin(); }
+                void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public: // from QSplineSeries
                 Q_INVOKABLE void append(qreal x, qreal y) { QSplineSeries::append(x, y); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { QSplineSeries::remove(x, y); }
                 Q_INVOKABLE void clear() { QSplineSeries::removeAll(); }
                 Q_INVOKABLE DeclarativeXyPoint *at(int index) { return DeclarativeXySeries::at(index); }
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESPLINESERIES_H

plugins/declarative/declarativexyseries.cpp +25 -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 "DeclarativeXySeries.h"
             #include "declarativexyseries.h"
             #include "declarativechart.h"
             #include <QXYSeries>
-            #include <QXYModelMapper>
+            #include <QVXYModelMapper>
+            #include <QHXYModelMapper>
             #include <QDeclarativeListProperty>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeXySeries::DeclarativeXySeries()
             {
             }
             DeclarativeXySeries::~DeclarativeXySeries()
             {
             }
+            void DeclarativeXySeries::classBegin()
+            {
+            }
+            void DeclarativeXySeries::componentComplete()
+            {
+                // All the inherited objects must be of type QXYSeries, so it is safe to cast
+                QXYSeries *series = reinterpret_cast<QXYSeries *>(this);
+                foreach(QObject *child, series->children()) {
+                    if (qobject_cast<DeclarativeXyPoint *>(child)) {
+                        // TODO:
+            //            series->append(qobject_cast<DeclarativeXyPoint *>(child));
+                    } else if(qobject_cast<QVXYModelMapper *>(child)) {
+                        QVXYModelMapper *mapper = qobject_cast<QVXYModelMapper *>(child);
+                        mapper->setSeries(series);
+                    } else if(qobject_cast<QHXYModelMapper *>(child)) {
+                        QHXYModelMapper *mapper = qobject_cast<QHXYModelMapper *>(child);
+                        mapper->setSeries(series);
+                    }
+                }
+            }
             QColor DeclarativeXySeries::penColor()
             {
                 // All the inherited objects must be of type QXYSeries, so it is safe to cast
                 QXYSeries *series = reinterpret_cast<QXYSeries *>(this);
                 return series->pen().color();
             }
             void DeclarativeXySeries::setPenColor(QColor color)
             {
                 QXYSeries *series = reinterpret_cast<QXYSeries *>(this);
                 QPen pen = series->pen();
                 pen.setColor(color);
                 series->setPen(pen);
             }
             DeclarativeXyPoint *DeclarativeXySeries::at(int index)
             {
                 QXYSeries *series = reinterpret_cast<QXYSeries *>(this);
                 if (index < series->count()) {
                     QPointF point = series->points().at(index);
                     DeclarativeXyPoint *xyPoint = new DeclarativeXyPoint(series);
                     xyPoint->setX(point.x());
                     xyPoint->setY(point.y());
                     return xyPoint;
                 }
                 return 0;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativexyseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVE_XY_SERIES_H
             #define DECLARATIVE_XY_SERIES_H
             #include "qchartglobal.h"
             #include "declarativexypoint.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QAbstractSeries;
             class DeclarativeXySeries
             {
             public:
                 explicit DeclarativeXySeries();
                 ~DeclarativeXySeries();
             public:
+                void classBegin();
+                void componentComplete();
                 QColor penColor();
                 void setPenColor(QColor color);
                 DeclarativeXyPoint *at(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVE_XY_SERIES_H

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

src/xychart/qxymodelmapper.cpp +3 0

             #include "qxymodelmapper.h"
             #include "qxymodelmapper_p.h"
             #include "qxyseries.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QXYModelMapper::QXYModelMapper(QObject *parent):
                 QObject(parent),
                 d_ptr(new QXYModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             }
             void QXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QXYModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeXYFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QXYSeries* QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;
             }
             void QXYModelMapper::setSeries(QXYSeries *series)
             {
                 Q_D(QXYModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeXYFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QXYModelMapper::first() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_first;
             }
             void QXYModelMapper::setFirst(int first)
             {
                 Q_D(QXYModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::count() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_count;
             }
             void QXYModelMapper::setCount(int count)
             {
                 Q_D(QXYModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeXYFromModel();
             }
             Qt::Orientation QXYModelMapper::orientation() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_orientation;
             }
             void QXYModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QXYModelMapper);
                 d->m_orientation = orientation;
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::xSection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_xSection;
             }
             void QXYModelMapper::setXSection(int xSection)
             {
                 Q_D(QXYModelMapper);
                 d->m_xSection = xSection;
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::ySection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_ySection;
             }
             void QXYModelMapper::setYSection(int ySection)
             {
                 Q_D(QXYModelMapper);
                 d->m_ySection = ySection;
                 d->initializeXYFromModel();
             }
             void QXYModelMapper::reset()
             {
                 Q_D(QXYModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_orientation = Qt::Vertical;
                 d->m_xSection = -1;
                 d->m_ySection = -1;
                 d->initializeXYFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYModelMapperPrivate::QXYModelMapperPrivate(QXYModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_xSection(-1),
                 m_ySection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QXYModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QXYModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QModelIndex QXYModelMapperPrivate::xModelIndex(int xPos)
             {
                 if (m_count != -1 && xPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(xPos + m_first, m_xSection);
                 else
                     return m_model->index(m_xSection, xPos + m_first);
             }
             QModelIndex QXYModelMapperPrivate::yModelIndex(int yPos)
             {
                 if (m_count != -1 && yPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(yPos + m_first, m_ySection);
                 else
                     return m_model->index(m_ySection, yPos + m_first);
             }
             void QXYModelMapperPrivate::handlePointAdded(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += 1;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(pointPos + m_first, 1);
                 else
                     m_model->insertColumns(pointPos + m_first, 1);
                 m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
                 m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointRemoved(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= 1;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRow(pointPos + m_first);
                 else
                     m_model->removeColumn(pointPos + m_first);
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointReplaced(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
                 m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
+                if (m_model == 0 || m_series == 0)
+                    return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 QPointF oldPoint;
                 QPointF newPoint;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         if (m_orientation == Qt::Vertical && (index.column() == m_xSection|| index.column() == m_ySection)) {
                             if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                                 oldPoint = m_series->points().at(index.row() - m_first);
                                 newPoint.setX(m_model->data(m_model->index(index.row(), m_xSection)).toReal());
                                 newPoint.setY(m_model->data(m_model->index(index.row(), m_ySection)).toReal());
                             }
                         } else if (m_orientation == Qt::Horizontal && (index.row() == m_xSection || index.row() == m_ySection)) {
                             if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
                                 oldPoint = m_series->points().at(index.column() - m_first);
                                 newPoint.setX(m_model->data(m_model->index(m_xSection, index.column())).toReal());
                                 newPoint.setY(m_model->data(m_model->index(m_ySection, index.column())).toReal());
                             }
                         } else {
                             continue;
                         }
                         m_series->replace(oldPoint, newPoint);
                     }
                     blockSeriesSignals(false);
                 }
             }
             void QXYModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::insertData(int start, int end)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int i = first; i <= last; i++) {
                         QPointF point;
                         point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                         point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                         m_series->insert(i - m_first, point);
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->points().size() > m_count)
                         for (int i = m_series->points().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->points().at(i));
                         }
                 }
             }
             void QXYModelMapperPrivate::removeData(int start, int end)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 int removedCount = end - start + 1;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } else {
                     int toRemove = qMin(m_series->points().size(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->points().size() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->points().at(i - m_first));
                     }
                     if (m_count != -1) {
                         int itemsAvailable;     // check how many are available to be added
                         if (m_orientation == Qt::Vertical)
                             itemsAvailable = m_model->rowCount() - m_first - m_series->points().size();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->points().size();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->points().size());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->points().size();
                         if (toBeAdded > 0)
                             for (int i = m_series->points().size(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 point.setX(m_model->data(xModelIndex(i), Qt::DisplayRole).toDouble());
                                 point.setY(m_model->data(yModelIndex(i), Qt::DisplayRole).toDouble());
                                 m_series->insert(i, point);
                             }
                     }
                 }
             }
             void QXYModelMapperPrivate::initializeXYFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial slices set
                 int pointPos = 0;
                 QModelIndex xIndex = xModelIndex(pointPos);
                 QModelIndex yIndex = yModelIndex(pointPos);
                 while (xIndex.isValid() && yIndex.isValid()) {
                     QPointF point;
                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                     point.setY(m_model->data(yIndex, Qt::DisplayRole).toDouble());
                     m_series->append(point);
                     pointPos++;
                     xIndex = xModelIndex(pointPos);
                     yIndex = yModelIndex(pointPos);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qxymodelmapper.cpp"
             #include "moc_qxymodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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