HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1507:4d1b1b063da8

QXYModelMapper removed from the docs

Marek Rosa -

r1507:4d1b1b063da8

parent child

Context file:

r1507:4d1b1b063da8

Collapse all files

demos/qmlcustommodel/qml/qmlcustommodel/main.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             import QmlCustomModel 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     id: chartView
                     title: "Top-5 car brand shares in Finland"
                     anchors.fill: parent
                     axisX.max: 10
                     axisX.min: 0
                     axisY.max: 20
                     axisY.min: 0
                     animationOptions: ChartView.SeriesAnimations
                     axisXLabels: [0, "2007", 1, "2008", 2, "2009", 3, "2010", 4, "2011", 5, "2012"]
                     // ...
                 //![1]
                     //![2]
                     CustomModel {
                         id: customModel
                         verticalHeaders: ["Manufacturer", "Volkswagen", "Toyota", "Ford", "Skoda", "Volvo", "Others"]
                         CustomModelElement { values: [0, "Manufacturer", 0, 1, 2, 3, 4] }
                         CustomModelElement { values: [1, "Volkswagen", 10.3, 12.0, 12.8, 13.0, 13.8] }
                         CustomModelElement { values: [2, "Toyota", 13.8, 13.5, 16.2, 13.7, 10.7] }
                         CustomModelElement { values: [3, "Ford", 6.4, 7.1, 8.9, 8.2, 8.6] }
                         CustomModelElement { values: [4, "Skoda", 4.7, 5.8, 6.9, 8.3, 8.2] }
                         CustomModelElement { values: [5, "Volvo", 7.1, 6.7, 6.5, 6.3, 7.0] }
                         CustomModelElement { values: [6, "Others", 57.7, 54.9, 48.7, 50.5, 51.7] }
                     }
                     //![2]
                     //![5]
                     BarSeries {
                         name: "Others"
                         barWidth: 0.9
                         visible: false
                         HBarModelMapper {
                             model: customModel
                             firstBarSetRow: 6
                             lastBarSetRow: 6
                             firstColumn: 2
                         }
                     }
                     //![5]
                     //![4]
                     LineSeries {
                         name: "Volkswagen"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 1
-                            first: 2
+                            firstColumn: 2
                         }
                     }
                     //![4]
                     LineSeries {
                         name: "Toyota"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 2
-                            first: 2
+                            firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Ford"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 3
-                            first: 2
+                            firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Skoda"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 4
-                            first: 2
+                            firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Volvo"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 5
-                            first: 2
+                            firstColumn: 2
                         }
                     }
                     //![3]
                     PieSeries {
                         id: pieSeries
                         size: 0.4
                         horizontalPosition: 0.7
                         verticalPosition: 0.4
                         onClicked: {
                             // Show the selection by exploding the slice
                             slice.exploded = !slice.exploded;
                             // Update the line series to show the yearly data for this slice
                             for (var i = 0; i < chartView.count; i++) {
                                 if (chartView.series(i).name == slice.label) {
                                     chartView.series(i).visible = slice.exploded;
                                 }
                             }
                         }
                     }
                     //![3]
                     VPieModelMapper {
                         series: pieSeries
                         model: customModel
                         labelsColumn: 1
                         valuesColumn: 2
                         firstRow: 1
                     }
                 }
             }

doc/src/classes.qdoc +1 -1

             /*!
                 \page classes.html
                 \title QtCommercial Charts API
                 \keyword All Classes
                 Charts API is build on top of Qt Graphics View Framework. Charts can be displayed as QGraphicsWidget using QChart class. However
                 there is also convenience class QChartView which is QWidget based. These lets quickly use QCharts as normal Qt widget.
                 The API supports following chart types:
                  \list
                  \o line
                  \o area
                  \o scatter
                  \o spline
                  \o pie
                  \o grouped bar
                  \o percent bar
                  \o stacked bar
                  \endlist
                 Each chart type is represented by QAbstractSeries derived class. To create given chart type users have to use instance of related series class and add it to QChart instance.
                 \code
                 QLineSeries* series = new QLineSeries();
                 series->add(0, 6);
                 series->add(2, 4);
                 ...
                 chartView->chart()->addSeries(series);
                 \endcode
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%">
                                 Common and global
                             </th>
                             <th class="titleheader" width="25%">
                                 XY chart
                             </th>
                         </tr>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qchart.html">QChart</a></li>
                                 <li><a href="qaxis.html">QAxis</a></li>
                                 <li><a href="qaxiscategories.html">QAxisCategories</a></li>
                                 <li><a href="qchartview.html">QChartView</a></li>
                                 <li><a href="qlegend.html">QLegend</a></li>
                                 <li><a href="qabstractseries.html">QAbstractSeries</a></li>
                                 <li><a href="qchartglobal.html">QChartGlobal</a></li>
                                 </ul>
                             </td>
                             <td valign="top">
                                 <ul>
+                                <li><a href="qxyseries.html">QXYSeries</a></li>
                                 <li><a href="qlineseries.html">QLineSeries</a></li>
                                 <li><a href="qareaseries.html">QAreaSeries</a></li>
                                 <li><a href="qscatterseries.html">QScatterSeries</a></li>
                                 <li><a href="qsplineseries.html">QSplineSeries</a></li>
-                                <li><a href="qxymodelmapper.html">QXYModelMapper</a></li>
                                 <li><a href="qhxymodelmapper.html">QHXYModelMapper</a></li>
                                 <li><a href="qvxymodelmapper.html">QVXYModelMapper</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%">
                                 Pie chart
                             </th>
                             <th class="titleheader" width="25%">
                                 Bar chart
                             </th>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qpieseries.html">QPieSeries</a></li>
                                 <li><a href="qpieslice.html">QPieSlice</a></li>
                                 <li><a href="qpiemodelmapper.html">QPieModelMapper</a></li>
                                 <li><a href="qhpiemodelmapper.html">QHPieModelMapper</a></li>
                                 <li><a href="qvpiemodelmapper.html">QVPieModelMapper</a></li>
                                 </ul>
                             </td>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qbarseries.html">QBarSeries</a></li>
                                 <li><a href="qbarset.html">QBarSet</a></li>
                                 <li><a href="qgroupedbarseries.html">QGroupedBarSeries</a></li>
                                 <li><a href="qpercentbarseries.html">QPercentBarSeries</a></li>
                                 <li><a href="qstackedbarseries.html">QStackedBarSeries</a></li>
                                 <li><a href="qbarmodelmapper.html">QBarModelMapper</a></li>
                                 <li><a href="qhbarmodelmapper.html">QHBarModelMapper</a></li>
                                 <li><a href="qvbarmodelmapper.html">QVBarModelMapper</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                 \endraw
             */

src/xychart/qhxymodelmapper.cpp +109 -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 "qhxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHXYModelMapper
-                \brief part of QtCommercial chart API.
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Horizontal model mapper is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
                 It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
+                \property QHXYModelMapper::series
+                \brief Defines the QXYSeries object that is used by the mapper.
+                All the data in the series is discarded when it is set to the mapper.
+                When new series is specified the old series is disconnected (it preserves its data)
+            */
+            /*!
+                \property QHXYModelMapper::model
+                \brief Defines the model that is used by the mapper.
+            */
+            /*!
                 \property QHXYModelMapper::xRow
                 \brief Defines which row of the model is kept in sync with the x values of the QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QHXYModelMapper::yRow
                 \brief Defines which row of the model is kept in sync with the  y values of the QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
+                \property QHXYModelMapper::firstColumn
+                \brief Defines which column of the model contains the data for the first point of the series.
+                Minimal and default value is: 0
+            */
+            /*!
+                \qmlproperty int QHXYModelMapper::firstColumn
+                Defines which column of the model contains the data for the first point of the series.
+                The default value is 0.
+            */
+            /*!
+                \property QHXYModelMapper::columnCount
+                \brief Defines the number of columns of the model that are mapped as the data for series
+                Minimal and default value is: -1 (count limited by the number of columns in the model)
+            */
+            /*!
+                \qmlproperty int QHXYModelMapper::columnCount
+                Defines the number of columns of the model that are mapped as the data for series. The default value is
+                -1 (count limited by the number of columns in the model)
+            */
+            /*!
+                \fn void QHXYModelMapper::seriesReplaced()
+                Emitted when the series to which mapper is connected to has changed.
+            */
+            /*!
+                \fn void QHXYModelMapper::modelReplaced()
+                Emitted when the model to which mapper is connected to has changed.
+            */
+            /*!
                 \fn void QHXYModelMapper::xRowChanged()
                 Emitted when the xRow has changed.
             */
             /*!
                 \fn void QHXYModelMapper::yRowChanged()
                 Emitted when the yRow has changed.
             */
             /*!
+                \fn void QHXYModelMapper::firstColumnChanged()
+                Emitted when the firstColumn has changed.
+            */
+            /*!
+                \fn void QHXYModelMapper::columnCountChanged()
+                Emitted when the columnCount has changed.
+            */
+            /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHXYModelMapper::QHXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Horizontal);
             }
+            QAbstractItemModel* QHXYModelMapper::model() const
+            {
+                return QXYModelMapper::model();
+            }
+            void QHXYModelMapper::setModel(QAbstractItemModel *model)
+            {
+                if (model != QXYModelMapper::model()) {
+                    QXYModelMapper::setModel(model);
+                    emit modelReplaced();
+                }
+            }
+            QXYSeries* QHXYModelMapper::series() const
+            {
+                return QXYModelMapper::series();
+            }
+            void QHXYModelMapper::setSeries(QXYSeries *series)
+            {
+                if (series != QXYModelMapper::series()) {
+                    QXYModelMapper::setSeries(series);
+                    emit seriesReplaced();
+                }
+            }
             int QHXYModelMapper::xRow() const
             {
                 return QXYModelMapper::xSection();
             }
             void QHXYModelMapper::setXRow(int xRow)
             {
                 if (xRow != xSection()) {
                     return QXYModelMapper::setXSection(xRow);
                     emit xRowChanged();
                 }
             }
             int QHXYModelMapper::yRow() const
             {
                 return QXYModelMapper::ySection();
             }
             void QHXYModelMapper::setYRow(int yRow)
             {
                 if (yRow != ySection()) {
                     return QXYModelMapper::setYSection(yRow);
                     emit yRowChanged();
                 }
             }
+            int QHXYModelMapper::firstColumn() const
+            {
+                return first();
+            }
+            void QHXYModelMapper::setFirstColumn(int firstColumn)
+            {
+                if (firstColumn != first()) {
+                    setFirst(firstColumn);
+                    emit firstColumnChanged();
+                }
+            }
+            int QHXYModelMapper::columnCount() const
+            {
+                return count();
+            }
+            void QHXYModelMapper::setColumnCount(int columnCount)
+            {
+                if (columnCount != count()) {
+                    setCount(columnCount);
+                    emit firstColumnChanged();
+                }
+            }
             #include "moc_qhxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qhxymodelmapper.h +20 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QHXYMODELMAPPER_H
             #define QHXYMODELMAPPER_H
             #include <QXYModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QHXYModelMapper : public QXYModelMapper
             {
                 Q_OBJECT
+                Q_PROPERTY(QXYSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
+                Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
                 Q_PROPERTY(int xRow READ xRow WRITE setXRow NOTIFY xRowChanged)
                 Q_PROPERTY(int yRow READ yRow WRITE setYRow NOTIFY yRowChanged)
+                Q_PROPERTY(int firstColumn READ firstColumn WRITE setFirstColumn NOTIFY firstColumnChanged)
+                Q_PROPERTY(int columnCount READ columnCount WRITE setColumnCount NOTIFY columnCountChanged)
             public:
                 explicit QHXYModelMapper(QObject *parent = 0);
+                QAbstractItemModel* model() const;
+                void setModel(QAbstractItemModel *model);
+                QXYSeries* series() const;
+                void setSeries(QXYSeries *series);
                 int xRow() const;
                 void setXRow(int xRow);
                 int yRow() const;
                 void setYRow(int yRow);
+                int firstColumn() const;
+                void setFirstColumn(int firstColumn);
+                int columnCount() const;
+                void setColumnCount(int columnCount);
             Q_SIGNALS:
+                void seriesReplaced();
+                void modelReplaced();
                 void xRowChanged();
                 void yRowChanged();
+                void firstColumnChanged();
+                void columnCountChanged();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHXYMODELMAPPER_H

src/xychart/qvxymodelmapper.cpp +109 -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 "qvxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVXYModelMapper
-                \brief part of QtCommercial chart API.
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
                 It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
+                \property QVXYModelMapper::series
+                \brief Defines the QXYSeries object that is used by the mapper.
+                All the data in the series is discarded when it is set to the mapper.
+                When new series is specified the old series is disconnected (it preserves its data)
+            */
+            /*!
+                \property QVXYModelMapper::model
+                \brief Defines the model that is used by the mapper.
+            */
+            /*!
                 \property QVXYModelMapper::xColumn
                 \brief Defines which column of the model is kept in sync with the x values of QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QVXYModelMapper::yColumn
                 \brief Defines which column of the model is kept in sync with the y values of QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
+                \property QVXYModelMapper::firstRow
+                \brief Defines which row of the model contains the data for the first point of the series.
+                Minimal and default value is: 0
+            */
+            /*!
+                \qmlproperty int QVXYModelMapper::firstRow
+                Defines which row of the model contains the data for the first point of the series.
+                The default value is 0.
+            */
+            /*!
+                \property QVXYModelMapper::rowCount
+                \brief Defines the number of rows of the model that are mapped as the data for series
+                Minimal and default value is: -1 (count limited by the number of rows in the model)
+            */
+            /*!
+                \qmlproperty int QVXYModelMapper::columnCount
+                Defines the number of rows of the model that are mapped as the data for series. The default value is
+                -1 (count limited by the number of rows in the model)
+            */
+            /*!
+                \fn void QVXYModelMapper::seriesReplaced()
+                Emitted when the series to which mapper is connected to has changed.
+            */
+            /*!
+                \fn void QVXYModelMapper::modelReplaced()
+                Emitted when the model to which mapper is connected to has changed.
+            */
+            /*!
                 \fn void QVXYModelMapper::xColumnChanged()
                 Emitted when the xColumn has changed.
             */
             /*!
                 \fn void QVXYModelMapper::yColumnChanged()
                 Emitted when the yColumn has changed.
             */
             /*!
+                \fn void QVXYModelMapper::firstRowChanged()
+                Emitted when the firstRow has changed.
+            */
+            /*!
+                \fn void QVXYModelMapper::rowCountChanged()
+                Emitted when the rowCount has changed.
+            */
+            /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVXYModelMapper::QVXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Vertical);
             }
+            QAbstractItemModel* QVXYModelMapper::model() const
+            {
+                return QXYModelMapper::model();
+            }
+            void QVXYModelMapper::setModel(QAbstractItemModel *model)
+            {
+                if (model != QXYModelMapper::model()) {
+                    QXYModelMapper::setModel(model);
+                    emit modelReplaced();
+                }
+            }
+            QXYSeries* QVXYModelMapper::series() const
+            {
+                return QXYModelMapper::series();
+            }
+            void QVXYModelMapper::setSeries(QXYSeries *series)
+            {
+                if (series != QXYModelMapper::series()) {
+                    QXYModelMapper::setSeries(series);
+                    emit seriesReplaced();
+                }
+            }
             int QVXYModelMapper::xColumn() const
             {
                 return QXYModelMapper::xSection();
             }
             void QVXYModelMapper::setXColumn(int xColumn)
             {
                 if (xColumn != xSection()) {
                     return QXYModelMapper::setXSection(xColumn);
                     emit xColumnChanged();
                 }
             }
             int QVXYModelMapper::yColumn() const
             {
                 return QXYModelMapper::ySection();
             }
             void QVXYModelMapper::setYColumn(int yColumn)
             {
                 if (yColumn != ySection()) {
                     return QXYModelMapper::setYSection(yColumn);
                     emit yColumnChanged();
                 }
             }
+            int QVXYModelMapper::firstRow() const
+            {
+                return first();
+            }
+            void QVXYModelMapper::setFirstRow(int firstRow)
+            {
+                if (firstRow != first()) {
+                    setFirst(firstRow);
+                    emit firstRowChanged();
+                }
+            }
+            int QVXYModelMapper::rowCount() const
+            {
+                return count();
+            }
+            void QVXYModelMapper::setRowCount(int rowCount)
+            {
+                if (rowCount != count()) {
+                    setCount(rowCount);
+                    emit firstRowChanged();
+                }
+            }
             #include "moc_qvxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qvxymodelmapper.h +20 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QVXYMODELMAPPER_H
             #define QVXYMODELMAPPER_H
             #include <QXYModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QVXYModelMapper : public QXYModelMapper
             {
                 Q_OBJECT
+                Q_PROPERTY(QXYSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
+                Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
                 Q_PROPERTY(int xColumn READ xColumn WRITE setXColumn NOTIFY xColumnChanged)
                 Q_PROPERTY(int yColumn READ yColumn WRITE setYColumn NOTIFY yColumnChanged)
+                Q_PROPERTY(int firstRow READ firstRow WRITE setFirstRow NOTIFY firstRowChanged)
+                Q_PROPERTY(int rowCount READ rowCount WRITE setRowCount NOTIFY rowCountChanged)
             public:
                 explicit QVXYModelMapper(QObject *parent = 0);
+                QAbstractItemModel* model() const;
+                void setModel(QAbstractItemModel *model);
+                QXYSeries* series() const;
+                void setSeries(QXYSeries *series);
                 int xColumn() const;
                 void setXColumn(int xColumn);
                 int yColumn() const;
                 void setYColumn(int yColumn);
+                int firstRow() const;
+                void setFirstRow(int firstRow);
+                int rowCount() const;
+                void setRowCount(int rowCount);
             Q_SIGNALS:
+                void seriesReplaced();
+                void modelReplaced();
                 void xColumnChanged();
                 void yColumnChanged();
+                void firstRowChanged();
+                void rowCountChanged();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVXYMODELMAPPER_H

src/xychart/qxymodelmapper.cpp +28 -93

             /****************************************************************************
             **
             ** 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 "qxymodelmapper.h"
             #include "qxymodelmapper_p.h"
             #include "qxyseries.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
-                \class QXYModelMapper
-                \brief part of QtCommercial chart API.
-                \mainclass
-                Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
-                The instance of this class cannot be created directly. QHXYModelMapper of QVXYModelMapper should be used instead. This class is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
-                It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
-                NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
-            */
-            /*!
-                \property QXYModelMapper::series
-                \brief Defines the QPieSeries object that is used by the mapper.
-                All the data in the series is discarded when it is set to the mapper.
-                When new series is specified the old series is disconnected (it preserves its data)
-            */
-            /*!
-                \property QXYModelMapper::model
-                \brief Defines the model that is used by the mapper.
-            */
-            /*!
-                \property QXYModelMapper::first
-                \brief Defines which item of the model's row/column should be mapped as the first x/y pair
-                Minimal and default value is: 0
-            */
-            /*!
-                \property QXYModelMapper::count
-                \brief Defines the number of rows/columns of the model that are mapped as the data for QXYSeries
-                Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
-            */
-            /*!
-                \fn void QXYModelMapper::seriesReplaced()
-                Emitted when the series to which mapper is connected to has changed.
-            */
-            /*!
-                \fn void QXYModelMapper::modelReplaced()
-                Emitted when the model to which mapper is connected to has changed.
-            */
-            /*!
-                \fn void QXYModelMapper::firstChanged()
-                Emitted when the value for the first has changed.
-            */
-            /*!
-                \fn void QXYModelMapper::countChanged()
-                Emitted when the value for the count has changed.
-            */
-            /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QXYModelMapper::QXYModelMapper(QObject *parent):
                 QObject(parent),
                 d_ptr(new QXYModelMapperPrivate(this))
             {
             }
+            /*!
+                \internal
+            */
             QAbstractItemModel* QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             }
+            /*!
+                \internal
+            */
             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)));
-                emit modelReplaced();
             }
+            /*!
+                \internal
+            */
             QXYSeries* QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;
             }
+            /*!
+                \internal
+            */
             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)));
-                emit seriesReplaced();
             }
+            /*!
+                \internal
+            */
             int QXYModelMapper::first() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_first;
             }
+            /*!
+                \internal
+            */
             void QXYModelMapper::setFirst(int first)
             {
                 Q_D(QXYModelMapper);
-                if (first != d->m_first) {
+                d->m_first = qMax(first, 0);
-                    d->m_first = qMax(first, 0);
+                d->initializeXYFromModel();
-                    d->initializeXYFromModel();
-                    emit firstChanged();
             }
+            /*!
+                \internal
+            */
             int QXYModelMapper::count() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_count;
             }
+            /*!
+                \internal
+            */
             void QXYModelMapper::setCount(int count)
             {
                 Q_D(QXYModelMapper);
-                if (count != d->m_count) {
+                d->m_count = qMax(count, -1);
-                    d->m_count = qMax(count, -1);
+                d->initializeXYFromModel();
-                    d->initializeXYFromModel();
-                    emit countChanged();
             }
             /*!
                 Returns the orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QXYModelMapper::orientation() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QXYModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QXYModelMapper);
                 d->m_orientation = orientation;
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the x values of the QXYSeries
             */
             int QXYModelMapper::xSection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_xSection;
             }
             /*!
                 Sets the model section that is kept in sync with the x values of the QXYSeries.
                 Parameter \a xSection specifies the section of the model.
             */
             void QXYModelMapper::setXSection(int xSection)
             {
                 Q_D(QXYModelMapper);
                 d->m_xSection = qMax(-1, xSection);
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the y values of the QXYSeries
             */
             int QXYModelMapper::ySection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_ySection;
             }
             /*!
                 Sets the model section that is kept in sync with the y values of the QXYSeries.
                 Parameter \a ySection specifies the section of the model.
             */
             void QXYModelMapper::setYSection(int ySection)
             {
                 Q_D(QXYModelMapper);
                 d->m_ySection = qMax(-1, ySection);
                 d->initializeXYFromModel();
             }
-            /*!
-                Resets the QXYModelMapper to the default state.
-                first: 0; count: -1; xSection: -1; ySection: -1;
-            */
-            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)) {
                                 QModelIndex xIndex = xModelIndex(index.row() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.row() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.row() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).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)) {
                                 QModelIndex xIndex = xModelIndex(index.column() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.column() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.column() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).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;
                         QModelIndex xIndex = xModelIndex(i - m_first);
                         QModelIndex yIndex = yModelIndex(i - m_first);
                         if (xIndex.isValid() && yIndex.isValid()) {
                             point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yIndex, 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->count(), 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->count() + 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->count();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->count();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->count());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->count();
                         if (toBeAdded > 0)
                             for (int i = m_series->count(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 QModelIndex xIndex = xModelIndex(i);
                                 QModelIndex yIndex = yModelIndex(i);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                                     point.setY(m_model->data(yIndex, 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

src/xychart/qxymodelmapper.h 0 -15

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QXYMODELMAPPER_H
             #define QXYMODELMAPPER_H
             #include "qchartglobal.h"
             #include <QObject>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYModelMapperPrivate;
             class QXYSeries;
             class QTCOMMERCIALCHART_EXPORT QXYModelMapper : public QObject
             {
                 Q_OBJECT
-                Q_PROPERTY(QXYSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
-                Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
-                Q_PROPERTY(int first READ first WRITE setFirst NOTIFY firstChanged)
-                Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)
-                Q_ENUMS(Qt::Orientation)
             protected:
                 explicit QXYModelMapper(QObject *parent = 0);
-            public:
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
                 QXYSeries* series() const;
                 void setSeries(QXYSeries *series);
                 int first() const;
                 void setFirst(int first);
                 int count() const;
                 void setCount(int count);
-                void reset();
-            protected:
                 Qt::Orientation orientation() const;
                 void setOrientation(Qt::Orientation orientation);
                 int xSection() const;
                 void setXSection(int xSection);
                 int ySection() const;
                 void setYSection(int ySection);
-            Q_SIGNALS:
-                void seriesReplaced();
-                void modelReplaced();
-                void firstChanged();
-                void countChanged();
             protected:
                 QXYModelMapperPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QXYModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYMODELMAPPER_H

tests/auto/qxymodelmapper/tst_qxymodelmapper.cpp +23 -23

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCore/QString>
             #include <QtTest/QtTest>
             #include <qchart.h>
             #include <qchartview.h>
             #include <qxyseries.h>
             #include <qlineseries.h>
             #include <qvxymodelmapper.h>
             #include <qhxymodelmapper.h>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_qxymodelmapper : public QObject
             {
                 Q_OBJECT
                 public:
                 tst_qxymodelmapper();
                 void createVerticalMapper();
                 void createHorizontalMapper();
                 private Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
                 void verticalMapper_data();
                 void verticalMapper();
                 void verticalMapperCustomMapping_data();
                 void verticalMapperCustomMapping();
                 void horizontalMapper_data();
                 void horizontalMapper();
                 void horizontalMapperCustomMapping_data();
                 void horizontalMapperCustomMapping();
                 void seriesUpdated();
                 void verticalModelInsertRows();
                 void verticalModelRemoveRows();
                 void verticalModelInsertColumns();
                 void verticalModelRemoveColumns();
                 void horizontalModelInsertRows();
                 void horizontalModelRemoveRows();
                 void horizontalModelInsertColumns();
                 void horizontalModelRemoveColumns();
                 void modelUpdateCell();
                 private:
                 QStandardItemModel *m_model;
                 int m_modelRowCount;
                 int m_modelColumnCount;
                 QHXYModelMapper *m_hMapper;
                 QVXYModelMapper *m_vMapper;
                 QXYSeries *m_series;
                 QChart *m_chart;
             };
             tst_qxymodelmapper::tst_qxymodelmapper():
                 m_model(0),
                 m_modelRowCount(10),
                 m_modelColumnCount(8),
                 m_hMapper(0),
                 m_vMapper(0),
                 m_series(0),
                 m_chart(0)
             {
             }
             void tst_qxymodelmapper::createVerticalMapper()
             {
                 m_vMapper = new QVXYModelMapper;
                 QVERIFY(m_vMapper->model() == 0);
                 m_vMapper->setXColumn(0);
                 m_vMapper->setYColumn(1);
                 m_vMapper->setModel(m_model);
                 m_vMapper->setSeries(m_series);
             }
             void tst_qxymodelmapper::createHorizontalMapper()
             {
                 m_hMapper = new QHXYModelMapper;
                 QVERIFY(m_hMapper->model() == 0);
                 m_hMapper->setXRow(0);
                 m_hMapper->setYRow(1);
                 m_hMapper->setModel(m_model);
                 m_hMapper->setSeries(m_series);
             }
             void tst_qxymodelmapper::init()
             {
                 m_series = new QLineSeries;
                 m_chart->addSeries(m_series);
                 m_model = new QStandardItemModel(m_modelRowCount, m_modelColumnCount, this);
                 for (int row = 0; row < m_modelRowCount; ++row) {
                     for (int column = 0; column < m_modelColumnCount; column++) {
                         m_model->setData(m_model->index(row, column), row * column);
                     }
                 }
             }
             void tst_qxymodelmapper::cleanup()
             {
                 m_chart->removeSeries(m_series);
                 m_series->deleteLater();
                 m_series = 0;
                 m_model->clear();
                 m_model->deleteLater();
                 m_model = 0;
                 if (m_vMapper) {
                     m_vMapper->deleteLater();
                     m_vMapper = 0;
                 }
                 if (m_hMapper) {
                     m_hMapper->deleteLater();
                     m_hMapper = 0;
                 }
             }
             void tst_qxymodelmapper::initTestCase()
             {
                 m_chart = new QChart;
                 QChartView *chartView = new QChartView(m_chart);
                 chartView->show();
             }
             void tst_qxymodelmapper::cleanupTestCase()
             {
                 //
             }
             void tst_qxymodelmapper::verticalMapper_data()
             {
                 QTest::addColumn<int>("xColumn");
                 QTest::addColumn<int>("yColumn");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("different x and y columns") << 0 << 1 << m_modelRowCount;
                 QTest::newRow("same x and y columns") << 1 << 1 << m_modelRowCount;
                 QTest::newRow("invalid x column and correct y column") << -3 << 1 << 0;
                 QTest::newRow("x column beyond the size of model and correct y column") << m_modelColumnCount << 1 << 0;
                 QTest::newRow("x column beyond the size of model and invalid y column") << m_modelColumnCount << -1 << 0;
             }
             void tst_qxymodelmapper::verticalMapper()
             {
                 QFETCH(int, xColumn);
                 QFETCH(int, yColumn);
                 QFETCH(int, expectedCount);
                 QVXYModelMapper *mapper = new QVXYModelMapper;
                 QVERIFY(mapper->model() == 0);
                 mapper->setXColumn(xColumn);
                 mapper->setYColumn(yColumn);
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
                 QCOMPARE(m_series->count(), expectedCount);
                 QCOMPARE(mapper->xColumn(), qMax(-1, xColumn));
                 QCOMPARE(mapper->yColumn(), qMax(-1, yColumn));
                 delete mapper;
                 mapper = 0;
             }
             void tst_qxymodelmapper::verticalMapperCustomMapping_data()
             {
                 QTest::addColumn<int>("first");
                 QTest::addColumn<int>("countLimit");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("first: 0, unlimited count") << 0 << -1 << m_modelRowCount;
                 QTest::newRow("first: 3, unlimited count") << 3 << -1 << m_modelRowCount - 3;
                 QTest::newRow("first: 0, count: 5") << 0 << 5 << qMin(5, m_modelRowCount);
                 QTest::newRow("first: 3, count: 5") << 3 << 5 << qMin(5, m_modelRowCount - 3);
                 QTest::newRow("first: +1 greater then the number of rows in the model, unlimited count") << m_modelRowCount + 1 << -1 << 0;
                 QTest::newRow("first: +1 greater then the number of rows in the model, count: 5") << m_modelRowCount + 1 << 5 << 0;
                 QTest::newRow("first: 0, count: +3 greater than the number of rows in the model (should limit to the size of model)") << 0 << m_modelRowCount + 3 << m_modelRowCount;
                 QTest::newRow("first: -3(invalid - should default to 0), unlimited count") << -3 << -1 << m_modelRowCount;
                 QTest::newRow("first: 0, count: -3 (invalid - shlould default to -1)") << 0 << -3 << m_modelRowCount;
                 QTest::newRow("first: -3(invalid - should default to 0), count: -3 (invalid - shlould default to -1)") << -3 << -3 << m_modelRowCount;
             }
             void tst_qxymodelmapper::verticalMapperCustomMapping()
             {
                 QFETCH(int, first);
                 QFETCH(int, countLimit);
                 QFETCH(int, expectedCount);
                 QCOMPARE(m_series->count(), 0);
                 QVXYModelMapper *mapper = new QVXYModelMapper;
                 mapper->setXColumn(0);
                 mapper->setYColumn(1);
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
-                mapper->setFirst(first);
+                mapper->setFirstRow(first);
-                mapper->setCount(countLimit);
+                mapper->setRowCount(countLimit);
                 QCOMPARE(m_series->count(), expectedCount);
                 // change values column mapping to invalid
                 mapper->setXColumn(-1);
                 mapper->setYColumn(1);
                 QCOMPARE(m_series->count(), 0);
                 delete mapper;
                 mapper = 0;
             }
             void tst_qxymodelmapper::horizontalMapper_data()
             {
                 QTest::addColumn<int>("xRow");
                 QTest::addColumn<int>("yRow");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("different x and y rows") << 0 << 1 << m_modelColumnCount;
                 QTest::newRow("same x and y rows") << 1 << 1 << m_modelColumnCount;
                 QTest::newRow("invalid x row and correct y row") << -3 << 1 << 0;
                 QTest::newRow("x row beyond the size of model and correct y row") << m_modelRowCount << 1 << 0;
                 QTest::newRow("x row beyond the size of model and invalid y row") << m_modelRowCount << -1 << 0;
             }
             void tst_qxymodelmapper::horizontalMapper()
             {
                 QFETCH(int, xRow);
                 QFETCH(int, yRow);
                 QFETCH(int, expectedCount);
                 QHXYModelMapper *mapper = new QHXYModelMapper;
                 mapper->setXRow(xRow);
                 mapper->setYRow(yRow);
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
                 QCOMPARE(m_series->count(), expectedCount);
                 QCOMPARE(mapper->xRow(), qMax(-1, xRow));
                 QCOMPARE(mapper->yRow(), qMax(-1, yRow));
                 delete mapper;
                 mapper = 0;
             }
             void tst_qxymodelmapper::horizontalMapperCustomMapping_data()
             {
                 QTest::addColumn<int>("first");
                 QTest::addColumn<int>("countLimit");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("first: 0, unlimited count") << 0 << -1 << m_modelColumnCount;
                 QTest::newRow("first: 3, unlimited count") << 3 << -1 << m_modelColumnCount - 3;
                 QTest::newRow("first: 0, count: 5") << 0 << 5 << qMin(5, m_modelColumnCount);
                 QTest::newRow("first: 3, count: 5") << 3 << 5 << qMin(5, m_modelColumnCount - 3);
                 QTest::newRow("first: +1 greater then the number of columns in the model, unlimited count") << m_modelColumnCount + 1 << -1 << 0;
                 QTest::newRow("first: +1 greater then the number of columns in the model, count: 5") << m_modelColumnCount + 1 << 5 << 0;
                 QTest::newRow("first: 0, count: +3 greater than the number of columns in the model (should limit to the size of model)") << 0 << m_modelColumnCount + 3 << m_modelColumnCount;
                 QTest::newRow("first: -3(invalid - should default to 0), unlimited count") << -3 << -1 << m_modelColumnCount;
                 QTest::newRow("first: 0, count: -3 (invalid - shlould default to -1)") << 0 << -3 << m_modelColumnCount;
                 QTest::newRow("first: -3(invalid - should default to 0), count: -3 (invalid - shlould default to -1)") << -3 << -3 << m_modelColumnCount;
             }
             void tst_qxymodelmapper::horizontalMapperCustomMapping()
             {
                 QFETCH(int, first);
                 QFETCH(int, countLimit);
                 QFETCH(int, expectedCount);
                 QCOMPARE(m_series->count(), 0);
                 QHXYModelMapper *mapper = new QHXYModelMapper;
                 mapper->setXRow(0);
                 mapper->setYRow(1);
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
-                mapper->setFirst(first);
+                mapper->setFirstColumn(first);
-                mapper->setCount(countLimit);
+                mapper->setColumnCount(countLimit);
                 QCOMPARE(m_series->count(), expectedCount);
                 // change values row mapping to invalid
                 mapper->setXRow(-1);
                 mapper->setYRow(1);
                 QCOMPARE(m_series->count(), 0);
                 delete mapper;
                 mapper = 0;
             }
             void tst_qxymodelmapper::seriesUpdated()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QCOMPARE(m_series->count(), m_modelRowCount);
-                QCOMPARE(m_vMapper->count(), -1);
+                QCOMPARE(m_vMapper->rowCount(), -1);
                 m_series->append(QPointF(100, 100));
                 QCOMPARE(m_series->count(), m_modelRowCount + 1);
-                QCOMPARE(m_vMapper->count(), -1); // the value should not change as it indicates 'all' items there are in the model
+                QCOMPARE(m_vMapper->rowCount(), -1); // the value should not change as it indicates 'all' items there are in the model
                 m_series->remove(m_series->points().last());
                 QCOMPARE(m_series->count(), m_modelRowCount);
-                QCOMPARE(m_vMapper->count(), -1); // the value should not change as it indicates 'all' items there are in the model
+                QCOMPARE(m_vMapper->rowCount(), -1); // the value should not change as it indicates 'all' items there are in the model
                 m_series->replace(m_series->points().first(), QPointF(25.0, 75.0));
                 QCOMPARE(m_model->data(m_model->index(0, 0)).toReal(), 25.0);
                 QCOMPARE(m_model->data(m_model->index(0, 1)).toReal(), 75.0);
             }
             void tst_qxymodelmapper::verticalModelInsertRows()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QCOMPARE(m_series->count(), m_modelRowCount);
                 QVERIFY(m_vMapper->model() != 0);
                 int insertCount = 4;
                 m_model->insertRows(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelRowCount + insertCount);
                 int first = 3;
-                m_vMapper->setFirst(3);
+                m_vMapper->setFirstRow(3);
                 QCOMPARE(m_series->count(), m_modelRowCount + insertCount - first);
                 m_model->insertRows(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelRowCount +  2 * insertCount - first);
                 int countLimit = 6;
-                m_vMapper->setCount(countLimit);
+                m_vMapper->setRowCount(countLimit);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount + 2 * insertCount - first));
                 m_model->insertRows(3, insertCount);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount + 3 * insertCount - first));
-                m_vMapper->setFirst(0);
+                m_vMapper->setFirstRow(0);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount + 3 * insertCount));
-                m_vMapper->setCount(-1);
+                m_vMapper->setRowCount(-1);
                 QCOMPARE(m_series->count(), m_modelRowCount + 3 * insertCount);
             }
             void tst_qxymodelmapper::verticalModelRemoveRows()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QCOMPARE(m_series->count(), m_modelRowCount);
                 QVERIFY(m_vMapper->model() != 0);
                 int removeCount = 2;
                 m_model->removeRows(1, removeCount);
                 QCOMPARE(m_series->count(), m_modelRowCount - removeCount);
                 int first = 1;
-                m_vMapper->setFirst(first);
+                m_vMapper->setFirstRow(first);
                 QCOMPARE(m_series->count(), m_modelRowCount - removeCount - first);
                 m_model->removeRows(1, removeCount);
                 QCOMPARE(m_series->count(), m_modelRowCount -  2 * removeCount - first);
                 int countLimit = 3;
-                m_vMapper->setCount(countLimit);
+                m_vMapper->setRowCount(countLimit);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount -  2 * removeCount - first));
                 m_model->removeRows(1, removeCount);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount -  3 * removeCount - first));
-                m_vMapper->setFirst(0);
+                m_vMapper->setFirstRow(0);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelRowCount -  3 * removeCount));
-                m_vMapper->setCount(-1);
+                m_vMapper->setRowCount(-1);
                 QCOMPARE(m_series->count(), m_modelRowCount -  3 * removeCount);
             }
             void tst_qxymodelmapper::verticalModelInsertColumns()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QCOMPARE(m_series->count(), m_modelRowCount);
                 QVERIFY(m_vMapper->model() != 0);
                 int insertCount = 4;
                 m_model->insertColumns(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelRowCount);
             }
             void tst_qxymodelmapper::verticalModelRemoveColumns()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QCOMPARE(m_series->count(), m_modelRowCount);
                 QVERIFY(m_vMapper->model() != 0);
                 int removeCount = m_modelColumnCount - 2;
                 m_model->removeColumns(0, removeCount);
                 QCOMPARE(m_series->count(), m_modelRowCount);
                 // leave only one column
                 m_model->removeColumns(0, m_modelColumnCount - removeCount - 1);
                 QCOMPARE(m_series->count(), 0);
             }
             void tst_qxymodelmapper::horizontalModelInsertRows()
             {
                 // setup the mapper
                 createHorizontalMapper();
                 QCOMPARE(m_series->count(), m_modelColumnCount);
                 QVERIFY(m_hMapper->model() != 0);
                 int insertCount = 4;
                 m_model->insertRows(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount);
             }
             void tst_qxymodelmapper::horizontalModelRemoveRows()
             {
                 // setup the mapper
                 createHorizontalMapper();
                 QCOMPARE(m_series->count(), m_modelColumnCount);
                 QVERIFY(m_hMapper->model() != 0);
                 int removeCount = m_modelRowCount - 2;
                 m_model->removeRows(0, removeCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount);
                 // leave only one column
                 m_model->removeRows(0, m_modelRowCount - removeCount - 1);
                 QCOMPARE(m_series->count(), 0);
             }
             void tst_qxymodelmapper::horizontalModelInsertColumns()
             {
                 // setup the mapper
                 createHorizontalMapper();
                 QCOMPARE(m_series->count(), m_modelColumnCount);
                 QVERIFY(m_hMapper->model() != 0);
                 int insertCount = 4;
                 m_model->insertColumns(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount + insertCount);
                 int first = 3;
-                m_hMapper->setFirst(3);
+                m_hMapper->setFirstColumn(3);
                 QCOMPARE(m_series->count(), m_modelColumnCount + insertCount - first);
                 m_model->insertColumns(3, insertCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount +  2 * insertCount - first);
                 int countLimit = 6;
-                m_hMapper->setCount(countLimit);
+                m_hMapper->setColumnCount(countLimit);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount + 2 * insertCount - first));
                 m_model->insertColumns(3, insertCount);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount + 3 * insertCount - first));
-                m_hMapper->setFirst(0);
+                m_hMapper->setFirstColumn(0);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount + 3 * insertCount));
-                m_hMapper->setCount(-1);
+                m_hMapper->setColumnCount(-1);
                 QCOMPARE(m_series->count(), m_modelColumnCount + 3 * insertCount);
             }
             void tst_qxymodelmapper::horizontalModelRemoveColumns()
             {
                 // setup the mapper
                 createHorizontalMapper();
                 QCOMPARE(m_series->count(), m_modelColumnCount);
                 QVERIFY(m_hMapper->model() != 0);
                 int removeCount = 2;
                 m_model->removeColumns(1, removeCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount - removeCount);
                 int first = 1;
-                m_hMapper->setFirst(first);
+                m_hMapper->setFirstColumn(first);
                 QCOMPARE(m_series->count(), m_modelColumnCount - removeCount - first);
                 m_model->removeColumns(1, removeCount);
                 QCOMPARE(m_series->count(), m_modelColumnCount -  2 * removeCount - first);
                 int countLimit = 3;
-                m_hMapper->setCount(countLimit);
+                m_hMapper->setColumnCount(countLimit);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount -  2 * removeCount - first));
                 m_model->removeColumns(1, removeCount);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount -  3 * removeCount - first));
-                m_hMapper->setFirst(0);
+                m_hMapper->setFirstColumn(0);
                 QCOMPARE(m_series->count(), qMin(countLimit, m_modelColumnCount -  3 * removeCount));
-                m_hMapper->setCount(-1);
+                m_hMapper->setColumnCount(-1);
                 QCOMPARE(m_series->count(), m_modelColumnCount -  3 * removeCount);
             }
             void tst_qxymodelmapper::modelUpdateCell()
             {
                 // setup the mapper
                 createVerticalMapper();
                 QVERIFY(m_model->setData(m_model->index(1, 0), 44));
                 QCOMPARE(m_series->points().at(1).x(), 44.0);
                 QCOMPARE(m_model->data(m_model->index(1, 0)).toReal(), 44.0);
             }
             QTEST_MAIN(tst_qxymodelmapper)
             #include "tst_qxymodelmapper.moc"

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