HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r630:dd8db9a3a988

Added support for data from model to QBarSeries. Various fixes and small modifications to data from model support to other series

Marek Rosa -

r630:dd8db9a3a988

parent child

Context file:

r630:dd8db9a3a988

Collapse all files

examples/examples.pro +1 -1

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatterchart \
                        piechart \
                        piechartdrilldown \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
                        chartview \
                        scatterinteractions \
                        splinechart \
                        areachart \
                        stackedbarchartdrilldown \
                        customcolors \
                        tablemodelchart \
-                       ekgchart
+                       #ekgchart

examples/splinechart/splinewidget.cpp +2 0

             #include "splinewidget.h"
             #include "qchartview.h"
             #include "qlineseries.h"
             #include <QGridLayout>
             #include <QPushButton>
             #include "qchartaxis.h"
             #include <qmath.h>
+            #include <QTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             SplineWidget::SplineWidget(QWidget *parent)
                 : QWidget(parent)
             {
             //    qsrand(time(NULL));
+                qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 //! [1]
                 //create QSplineSeries
                 series = new QSplineSeries(this);
                 //! [1]
                 //! [2]
                 // customize the series presentation settings
                 QPen seriesPen(Qt::blue);
                 seriesPen.setWidth(3);
             //    series->setPen(seriesPen);
                 //! [2]
                 //! [add points to series]
                 //add data points to the series
                 series->add(QPointF(150, 100));
                 series->add(QPointF(200, 130));
                 series->add(QPointF(250, 120));
                 series->add(QPointF(300, 140));
                 series->add(QPointF(350, 160));
                 //! [add points to series]
                 QSplineSeries* series2 = new QSplineSeries;
                 series2->add(QPointF(400, 120));
                 series2->add(QPointF(450, 150));
                 series2->add(QPointF(500, 145));
                 series2->add(QPointF(550, 170));
             //    series->add(QPointF(600, 190));
             //    series->add(QPointF(650, 210));
             //    series->add(QPointF(700, 190));
             //    series->add(QPointF(750, 180));
             //    series->add(QPointF(800, 170));
                 QSplineSeries* series3 = new QSplineSeries;
                     series3->add(QPointF(600, 190));
                     series3->add(QPointF(650, 210));
                     series3->add(QPointF(700, 190));
                     series3->add(QPointF(750, 180));
                     series3->add(QPointF(800, 170));
                 //! [3]
                 // create chart view
                 QChartView* chart = new QChartView;
                 chart->addSeries(series);
                 chart->addSeries(series2);
                 chart->addSeries(series3);
                 chart->setChartTitle("Spline chart example");
                 chart->axisX()->setMax(1500);
                 chart->axisY()->setMax(500);
                 chart->setMinimumSize(800,600);
                 //! [3]
                 //! [4]
                 //add new data point button
                 QPushButton* addButton = new QPushButton("Add new point");
                 connect(addButton, SIGNAL(clicked()), this, SLOT(addNewPoint()));
                 // remove the last data point in the series
                 QPushButton* removeButton = new QPushButton("Remove point");
                 connect(removeButton, SIGNAL(clicked()), this, SLOT(removePoint()));
                 //! [4]
                 //! [5]
                 //butttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(addButton);
                 buttonsLayout->addWidget(removeButton);
                 buttonsLayout->addStretch();
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chart, 1, 0);
                 mainLayout->addLayout(buttonsLayout, 1, 1);
                 setLayout(mainLayout);
                 //! [5]
             }
             //! [add point]
             void SplineWidget::addNewPoint()
             {
                 if (series->count() > 0)
                     series->add(QPointF(series->x(series->count() - 1) + 40 + qrand()%40, qAbs(series->y(series->count() - 1) - 50 + qrand()%100)));
                 else
                     series->add(QPointF(50, 50 + qrand()%50));
             }
             //! [add point]
             //! [remove point]
             void SplineWidget::removePoint()
             {
                 if (series->count() > 0)
                     series->remove(QPointF(series->x(series->count() - 1), series->y(series->count() - 1)));
             }
             //! [remove point]
             SplineWidget::~SplineWidget()
             {
             }

examples/tablemodelchart/customtablemodel.cpp +94 -41

             #include "customtablemodel.h"
+            #include <QVector>
             CustomTableModel::CustomTableModel(QObject *parent) :
                 QAbstractTableModel(parent)
             {
-                m_points.append(QPointF(10, 50));
+            //    m_points.append(QPointF(10, 50));
-                m_labels.append("Apples");
+            //    m_labels.append("Apples");
-                m_points.append(QPointF(60, 70));
+            //    m_points.append(QPointF(60, 70));
-                m_labels.append("Oranges");
+            //    m_labels.append("Oranges");
-                m_points.append(QPointF(110, 50));
+            //    m_points.append(QPointF(110, 50));
-                m_labels.append("Bananas");
+            //    m_labels.append("Bananas");
-                m_points.append(QPointF(140, 40));
+            //    m_points.append(QPointF(140, 40));
-                m_labels.append("Lemons");
+            //    m_labels.append("Lemons");
-                m_points.append(QPointF(200, 150));
+            //    m_points.append(QPointF(200, 150));
-                m_labels.append("Plums");
+            //    m_labels.append("Plums");
-                m_points.append(QPointF(225, 75));
+            //    m_points.append(QPointF(225, 75));
-                m_labels.append("Pearls");
+                //    m_labels.append("Pearls");
+                // m_data
+                for (int i = 0; i < 6; i++)
+                {
+                    QVector<qreal>* dataVec = new QVector<qreal>(6);
+                    for (int k = 0; k < dataVec->size(); k++)
+                        if (k%2 == 0)
+                            dataVec->replace(k, i * 50 + qrand()%20);
+                        else
+                            dataVec->replace(k, qrand()%100);
+                    m_data.append(dataVec);
+                    m_labels.append(QString("Row: %1").arg((i + 1)));
+                }
             }
             int CustomTableModel::rowCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
-                return m_points.count();
+                //    return m_points.count();
+                return m_data.count();
             }
             int CustomTableModel::columnCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
-                return 3;
+                //    return 3;
+                return 6;
             }
             QVariant CustomTableModel::headerData (int section, Qt::Orientation orientation, int role ) const
             {
                 if (role != Qt::DisplayRole)
                     return QVariant();
                 if (orientation == Qt::Horizontal)
                 {
                     switch(section)
                     {
-                    case 0:
+                    //        case 0:
-                        return "x";
+                    //            return "x";
-                    case 1:
+                    //        case 1:
-                        return "y";
+                    //            return "y";
-                    case 2:
+                    //        case 2:
+                    case 6:
                         return "Fruit";
                     default:
-                        return "What?";
+                        if (section%2 == 0)
+                            return "x";
+                        else
+                            return "y";
+                        //            return "What?";
                     }
                 }
                 else
                     return QString("%1").arg(section + 1);
             }
             QVariant CustomTableModel::data(const QModelIndex & index, int role) const
             {
                 if (role == Qt::DisplayRole)
                 {
                     switch(index.column())
                     {
-                    case 0:
+                    //        case 0:
-                        return m_points[index.row()].x();
+                    //            return m_points[index.row()].x();
-                    case 1:
+                    //        case 1:
-                        return m_points[index.row()].y();
+                    //            return m_points[index.row()].y();
-                    case 2:
+                    //        case 2:
+                    case 6:
                         return m_labels[index.row()];
                     default:
+                        return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 else if (role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
-                    case 0:
+                    //        case 0:
-                        return m_points[index.row()].x();
+                    //            return m_points[index.row()].x();
-                    case 1:
+                    //        case 1:
-                        return m_points[index.row()].y();
+                    //            return m_points[index.row()].y();
-                    case 2:
+                    //        case 2:
+                    case 6:
                         return m_labels[index.row()];
                     default:
+                        return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 return QVariant();
             }
             bool CustomTableModel::setData ( const QModelIndex & index, const QVariant & value, int role)
             {
                 if (index.isValid() && role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
-                    case 0:
+                    //        case 0:
-                        m_points[index.row()].setX(value.toDouble());
+                    //            m_points[index.row()].setX(value.toDouble());
-                        break;
+                    //            break;
-                    case 1:
+                    //        case 1:
-                        m_points[index.row()].setY(value.toDouble());
+                    //            m_points[index.row()].setY(value.toDouble());
-                        break;
+                    //            break;
-                    case 2:
+                    //        case 2:
+                    case 6:
                         m_labels.replace(index.row(), value.toString());
                         break;
                     default:
-                        return false;
+                        m_data[index.row()]->replace(index.column(), value.toDouble());
+                        break;
+                        //            return false;
                     }
                     emit dataChanged(index, index);
                     return true;
                 }
                 return false;
             }
             Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
             {
                 //    if (!index.isValid())
                 //                return Qt::ItemIsEnabled;
                 return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
             }
             bool CustomTableModel::insertRows ( int row, int count, const QModelIndex & parent)
             {
                 Q_UNUSED(parent)
                 if (row < 0)
                     row = 0;
                 beginInsertRows(QModelIndex(), row /*dataTable.count()*/, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
-                    m_points.insert(row, QPointF(10,20));
+                    //        m_points.insert(row, QPointF(10,20));
-                    m_labels.insert(row,("a"));
+                    QVector<qreal>* dataVec = new QVector<qreal>(6);
+                    for (int k = 0; k < dataVec->size(); k++)
+                        if (k%2 == 0)
+                            //                dataVec->replace(k, i * 50 + qrand()%20);
+                        {
+                            int difference = 0;
+                            if (row < m_data.size())
+                            {
+                                if (row - 1 >= 0)
+                                {
+                                    difference = (int)(qAbs(m_data[row]->at(k) - m_data[row - 1]->at(k)));
+                                    dataVec->replace(k, m_data[row - 1]->at(k) + qrand()%qMax(1, difference));
+                                }
+                                else
+                                    dataVec->replace(k, qrand()%20);
+                            }
+                            else
+                                dataVec->replace(k, m_data[row - 1]->at(k) + qrand()%20);
+                        }
+                        else
+                            dataVec->replace(k, qrand()%100);
+                    m_data.insert(row, dataVec);
+                    m_labels.insert(row,(QString("Row: %1").arg(row + 1)));
                 }
                 endInsertRows();
                 return true;
             }
             bool CustomTableModel::removeRows ( int row, int count, const QModelIndex & parent)
             {
                 if (row > this->rowCount() - 1)
                     return false;
                 if (row < 0)
                     row = 0;
                 if (row + count > rowCount())
                     return false;
                 beginRemoveRows(parent, row, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
-                    m_points.removeAt(row);
+            //        m_points.removeAt(row);
+                    QVector<qreal>* item = m_data.at(row);
+                    m_data.removeAt(row);
+                    delete item;
                     m_labels.removeAt(row);
                 }
                 endRemoveRows();
                 return true;
             }

examples/tablemodelchart/customtablemodel.h +1 0

             #ifndef XYPOINTSMODEL_H
             #define XYPOINTSMODEL_H
             #include <QAbstractTableModel>
             #include <QPointF>
             #include <QStringList>
             class CustomTableModel : public QAbstractTableModel
             {
                 Q_OBJECT
             public:
                 explicit CustomTableModel(QObject *parent = 0);
                 int rowCount ( const QModelIndex & parent = QModelIndex() ) const;
                 int columnCount ( const QModelIndex & parent = QModelIndex() ) const;
                 QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
                 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
                 bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
                 Qt::ItemFlags flags ( const QModelIndex & index ) const;
                 bool insertRows ( int row, int count, const QModelIndex & parent = QModelIndex() );
                 bool removeRows ( int row, int count, const QModelIndex & parent = QModelIndex() );
                 //signals:
                 //public slots:
             private:
+                QList<QVector<qreal>* > m_data;
                 QList<QPointF> m_points;
                 QStringList m_labels;
             };
             #endif // XYPOINTSMODEL_H

examples/tablemodelchart/tablewidget.cpp +126 -10

             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QStyledItemDelegate>
             #include "qlineseries.h"
             #include "qsplineseries.h"
             #include "qscatterseries.h"
             #include "customtablemodel.h"
             #include "qpieseries.h"
+            #include "qareaseries.h"
+            #include "qbarseries.h"
             #include <QPushButton>
             #include <QRadioButton>
+            #include <QTime>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
+                qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 tableView = new QTableView;
                 tableView->setModel(m_model);
-                tableView->setMinimumSize(340, 480);
+                tableView->setMinimumHeight(240);
+            //    tableView->setMinimumSize(340, 480);
             //    tableView->setItemDelegate(new QStyledItemDelegate);
                 chartView = new QChartView(this);
+                chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setMinimumSize(640, 480);
                 // create
             //    QLineSeries* series = new QLineSeries;
             //    QSplineSeries* series = new QSplineSeries;
             //    QScatterSeries* series = new QScatterSeries;
             //    series->setModel(m_model);
             //    series->setModelMapping(0,1, Qt::Vertical);
             //    QPieSeries* pieSeries = new QPieSeries;
             //    pieSeries->setModel(model);
             //    pieSeries
             //    chartView->addSeries(series);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 lineRadioButton = new QRadioButton("Line");
                 splineRadioButton = new QRadioButton("Spline");
                 scatterRadioButton = new QRadioButton("Scatter");
                 pieRadioButton = new QRadioButton("Pie");
+                areaRadioButton = new QRadioButton("Area");
+                barRadioButton = new QRadioButton("Bar");
                 connect(lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
+                connect(areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
+                connect(barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 lineRadioButton->setChecked(true);
                 // radio buttons layout
-                QHBoxLayout* radioLayout = new QHBoxLayout;
+                QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(lineRadioButton);
                 radioLayout->addWidget(splineRadioButton);
                 radioLayout->addWidget(scatterRadioButton);
                 radioLayout->addWidget(pieRadioButton);
+                radioLayout->addWidget(areaRadioButton);
+                radioLayout->addWidget(barRadioButton);
+                radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
-                mainLayout->addLayout(buttonsLayout, 0, 1);
+                mainLayout->addLayout(buttonsLayout, 1, 0);
-                mainLayout->addLayout(radioLayout, 0, 2);
+                mainLayout->addLayout(radioLayout, 2, 0);
                 mainLayout->addWidget(tableView, 1, 1);
-                mainLayout->addWidget(chartView, 1, 2);
+                mainLayout->addWidget(chartView, 2, 1);
                 setLayout(mainLayout);
+                lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
             //    m_model->insertRow(m_model->rowCount());
                 m_model->insertRow(tableView->currentIndex().row());
             }
             void TableWidget::addRowBelow()
             {
             //    m_model->insertRow(m_model->rowCount());
                 m_model->insertRow(tableView->currentIndex().row() + 1);
             }
             void TableWidget::removeRow()
             {
             //    m_model->removeRow(m_model->rowCount() - 1);
                 m_model->removeRow(tableView->currentIndex().row());
             }
             void TableWidget::updateChartType()
             {
                 chartView->removeAllSeries();
                 if (lineRadioButton->isChecked())
+                {
+                    // series 1
+                    series = new QLineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(0,1, Qt::Vertical);
+            //        series->setModelMapping(0,1, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 2
                     series = new QLineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(2,3, Qt::Vertical);
+            //        series->setModelMapping(2,3, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 3
+                    series = new QLineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(4,5, Qt::Vertical);
+            //        series->setModelMapping(4,5, Qt::Horizontal);
+                    chartView->addSeries(series);
+                }
                 else if (splineRadioButton->isChecked())
+                {
+                    // series 1
                     series = new QSplineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(0,1, Qt::Vertical);
+            //        series->setModelMapping(0,1, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 2
+                    series = new QSplineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(2,3, Qt::Vertical);
+            //        series->setModelMapping(2,3, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 3
+                    series = new QSplineSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(4,5, Qt::Vertical);
+            //        series->setModelMapping(4,5, Qt::Horizontal);
+                    chartView->addSeries(series);
+                }
                 else if (scatterRadioButton->isChecked())
+                {
+                    // series 1
                     series = new QScatterSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(0,1, Qt::Vertical);
+            //        series->setModelMapping(0,1, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 2
+                    series = new QScatterSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(2,3, Qt::Vertical);
+            //        series->setModelMapping(2,3, Qt::Horizontal);
+                    chartView->addSeries(series);
+                    // series 3
+                    series = new QScatterSeries;
+                    series->setModel(m_model);
+                    series->setModelMapping(4,5, Qt::Vertical);
+            //        series->setModelMapping(4,5, Qt::Horizontal);
+                    chartView->addSeries(series);
+                }
                 else if (pieRadioButton->isChecked())
                 {
+                    // pie 1
                     QPieSeries* pieSeries = new QPieSeries;
                     pieSeries->setModel(m_model);
-                    pieSeries->setModelMapping(0,2, Qt::Vertical);
+                    pieSeries->setModelMapping(0,0, Qt::Horizontal);
+                    pieSeries->setLabelsVisible(true);
+                    pieSeries->setPieSize(0.4);
+                    pieSeries->setPiePosition(0.2, 0.35);
+                    chartView->addSeries(pieSeries);
+                    // pie 2
+                    pieSeries = new QPieSeries;
+                    pieSeries->setModel(m_model);
+                    pieSeries->setModelMapping(1,1, Qt::Horizontal);
                     pieSeries->setLabelsVisible(true);
+                    pieSeries->setPieSize(0.4);
+                    pieSeries->setPiePosition(0.8, 0.35);
                     chartView->addSeries(pieSeries);
-                    return;
+                    // pie 3
+                    pieSeries = new QPieSeries;
+                    pieSeries->setModel(m_model);
+                    pieSeries->setModelMapping(2,2, Qt::Horizontal);
+                    pieSeries->setLabelsVisible(true);
+                    pieSeries->setPieSize(0.4);
+                    pieSeries->setPiePosition(0.5, 0.65);
+                    chartView->addSeries(pieSeries);
+                }
+                else if (areaRadioButton->isChecked())
+                {
+                    QLineSeries* upperLineSeries = new QLineSeries;
+                    upperLineSeries->setModel(m_model);
+                    upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
+                    QLineSeries* lowerLineSeries = new QLineSeries;
+                    lowerLineSeries->setModel(m_model);
+                    lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
+                    QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
+                    chartView->addSeries(areaSeries);
+                }
+                else if (barRadioButton->isChecked())
+                {
+                    QBarSeries* barSeries = new QBarSeries(QStringList());
+                    barSeries->setModel(m_model);
+                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
+                    barSeries->setToolTipEnabled(true);
+                    chartView->addSeries(barSeries);
                 }
-                series->setModel(m_model);
+            //    series->setModel(m_model);
-                series->setModelMapping(0,1, Qt::Vertical);
+            //    series->setModelMapping(0,1, Qt::Vertical);
-                chartView->addSeries(series);
+            //    chartView->addSeries(series);
             }
             TableWidget::~TableWidget()
             {
             }

examples/tablemodelchart/tablewidget.h +2 0

             #ifndef TABLEWIDGET_H
             #define TABLEWIDGET_H
             #include <QtGui/QWidget>
             #include "qchartview.h"
             #include "qxyseries.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             class CustomTableModel;
             class QTableView;
             class QRadioButton;
             //class QSeries;
             class TableWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 TableWidget(QWidget *parent = 0);
                 ~TableWidget();
                 public slots:
                 void addRowAbove();
                 void addRowBelow();
                 void removeRow();
                 void updateChartType();
                 private:
                 QChartView* chartView;
                 QXYSeries* series;
                 CustomTableModel* m_model;
                 QTableView* tableView;
                 QRadioButton* lineRadioButton;
                 QRadioButton* splineRadioButton;
                 QRadioButton* scatterRadioButton;
                 QRadioButton* pieRadioButton;
+                QRadioButton* areaRadioButton;
+                QRadioButton* barRadioButton;
             };
             #endif // TABLEWIDGET_H

src/areachart/qareaseries.cpp +19 0

             #include "qareaseries.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
             	\image areachart.png
             	Creating basic area chart is simple:
             	\code
             	QLineSeries* lineSeries = new QLineSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	QAreaSeries* areaSeries = new QAreaSeries(lineSeries);
             	...
             	chartView->addSeries(areaSeries);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QAreaSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn QLineSeries* QAreaSeries::upperSeries() const
                \brief Returns upperSeries used to define one of area boundaries.
             */
             /*!
                \fn QLineSeries* QAreaSeries::lowerSeries() const
                \brief Returns lowerSeries used to define one of area boundaries. Note if QAreaSeries where counstucted wihtout a\ lowerSeries
                 this function return Null pointer.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                \fn bool  QAreaSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QAreaSeries::QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries):QSeries(upperSeries),
             m_upperSeries(upperSeries),
             m_lowerSeries(lowerSeries),
             m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen& pen)
             {
                 if(m_pen!=pen){
                     m_pen=pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush& brush)
             {
                 if(m_brush!=brush){
                     m_brush=brush;
                     emit updated();
                 }
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 if(m_pointsVisible!=visible){
                     m_pointsVisible=visible;
                     emit updated();
                 }
             }
+            //bool QAreaSeries::setModel(QAbstractItemModel* model)
+            //{
+            //    m_upperSeries->setModel(model);
+            //    if (m_lowerSeries)
+            //        m_lowerSeries->setModel(model);
+            //    return true;
+            //}
+            //void QAreaSeries::setModelMappingUpper(int modelX, int modelY, Qt::Orientation orientation)
+            //{
+            //    m_upperSeries->setModelMapping(modelX, modelY, orientation);
+            //}
+            //void QAreaSeries::setModelMappingLower(int modelX, int modelY, Qt::Orientation orientation)
+            //{
+            //    if (m_lowerSeries)
+            //        m_lowerSeries->setModelMapping(modelX, modelY, orientation);
+            //}
             #include "moc_qareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.h +4 0

             #ifndef QAREASERIES_H_
             #define QAREASERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries=0);
                 virtual ~QAreaSeries();
             public: // from QChartSeries
                 virtual QSeriesType type() const { return QSeries::SeriesTypeArea;}
                 QLineSeries* upperSeries() const { return m_upperSeries;}
                 QLineSeries* lowerSeries() const { return m_lowerSeries;}
                 void setPen(const QPen& pen);
                 QPen pen() const { return m_pen;}
                 void setBrush(const QBrush& brush);
                 QBrush brush() const { return m_brush;}
                 void setPointsVisible(bool visible);
                 bool pointsVisible() const {return m_pointsVisible;}
+            //    bool setModel(QAbstractItemModel* model);
+            //    void setModelMappingUpper(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
+            //    void setModelMappingLower(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             signals:
                 void updated();
                 void clicked(const QPointF& point);
             private:
                 QBrush m_brush;
                 QPen m_pen;
                 QLineSeries* m_upperSeries;
                 QLineSeries* m_lowerSeries;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qbarseries.cpp +111 -6

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QStringList categories, QObject *parent)
                 : QSeries(parent)
                 ,mModel(new BarChartModel(categories, this))
             {
                 m_model = NULL;
                 m_mapCategories = -1;
                 m_mapBarBottom = -1;
                 m_mapBarTop = -1;
+                m_mapOrientation = Qt::Vertical;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
+                connect(set, SIGNAL(changed()), this, SLOT(barsetChanged()));
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
-                if(m_model)
+            //    if(m_model)
-                    return m_mapBarTop - m_mapBarBottom;
+            //        return m_mapBarTop - m_mapBarBottom;
-                else
+            //    else
                     return mModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
                 return mModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
                 return mModel->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
                 emit enableSeparators(visible);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
             bool QBarSeries::separatorsVisible()
             {
                 return mSeparatorsVisible;
             }
             bool QBarSeries::setModel(QAbstractItemModel* model)
             {
+                // disconnect signals from old model
+                if(m_model)
+                {
+                    disconnect(m_model, 0, this, 0);
+                    m_mapCategories = -1;
+                    m_mapBarBottom = -1;
+                    m_mapBarTop = -1;
+                    m_mapOrientation = Qt::Vertical;
+                }
+                // set new model
+                if(model)
+                {
                     m_model = model;
                     return true;
                 }
+                else
+                {
+                    m_model = NULL;
+                    return false;
+                }
+            }
             // TODO
-            void QBarSeries::setModelMappingCategories(int /*modelColumn*/)
+            void QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
+            {
+                if (m_model == NULL)
+                    return;
+                m_mapCategories = categories;
+                m_mapBarBottom = bottomBoundry;
+                m_mapBarTop = topBoundry;
+                m_mapOrientation = orientation;
+                // connect the signals
+                if (m_mapOrientation == Qt::Vertical)
+                {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
+                else
                 {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
-            // TODO
-            void QBarSeries::setModelMappingBarRange(int /*bottomBoundry*/, int /*topBoundry*/)
+                // create the initial bars
+                delete mModel;
+                if (m_mapOrientation == Qt::Vertical)
+                {
+                    QStringList categories;
+                    for (int k = 0; k < m_model->columnCount(); k++)
+                        categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
+                    mModel = new BarChartModel(categories, this);
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
+                    {
+                        QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
+                        for(int m = 0; m < m_model->columnCount(); m++)
+                            *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
+                        addBarSet(barSet);
+                    }
+                }
+                else
+                {
+                    QStringList categories;
+                    for (int k = 0; k < m_model->rowCount(); k++)
+                        categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
+                    mModel = new BarChartModel(categories, this);
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
+                    {
+                        QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
+                        for(int m = 0; m < m_model->rowCount(); m++)
+                            *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
+                        addBarSet(barSet);
+                    }
+                }
+            }
+            void QBarSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
+            {
+                Q_UNUSED(bottomRight)
+                if (m_mapOrientation == Qt::Vertical)
+                {
+                    if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop)
+                        barsetAt(topLeft.row())->setValue(topLeft.column(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
+            //        else if (topLeft.column() == m_mapCategories)
+            //            slices().at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
+                }
+                else
+                {
+                    if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop)
+                        barsetAt(topLeft.column())->setValue(topLeft.row(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
+            //        else if (topLeft.row() == m_mapCategories)
+            //            slices().at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
+                }
+            }
+            void QBarSeries::modelDataAdded(QModelIndex /*parent*/, int /*start*/, int /*end*/)
+            {
+                //
+            }
+            void QBarSeries::modelDataRemoved(QModelIndex /*parent*/, int /*start*/, int /*end*/)
+            {
+                //
+            }
+            void QBarSeries::barsetChanged()
             {
+            //    mModel->
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +9 -2

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include "qseries.h"
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* modelExt() {return m_model;}
-                void setModelMappingCategories(int modelColumn);
+                void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
-                void setModelMappingBarRange(int bottomBoundry, int topBoundry);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 bool separatorsVisible();
                 // <--- TO PIMPL
             signals:
                 //void changed(int index);
                 void clicked(QBarSet* barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet* barset, QString category);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void enableSeparators(bool enable);
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 void setSeparatorsVisible(bool visible=true);        // enables separators between categories
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
+            private Q_SLOTS:
+                // slots for updating bars when data in model changes
+                void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
+                void modelDataAdded(QModelIndex parent, int start, int end);
+                void modelDataRemoved(QModelIndex parent, int start, int end);
+                void barsetChanged();
             protected:
                 BarChartModel* mModel;
                 bool mSeparatorsVisible;
                 QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
+                Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +1 0

             #include "qbarset.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::rightClicked(QString category)
                 \brief signals that set has been clicked with right mouse button
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hoverEnter(QPoint pos)
                 \brief signals that mouse has entered over the set at position \a pos.
             */
             /*!
                 \fn void QBarSet::hoverLeave()
                 \brief signals that mouse has left from the set.
             */
             /*!
                 \fn void QBarSet::toggleFloatingValues()
                 \brief \internal
             */
             /*!
                 \fn void QBarSet::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
                 ,mName(name)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name()
             {
                 return mName;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count()
             {
                 return mValues.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
                 mValues.replace(index,value);
+                emit changed();
             }
             /*!
                 Returns total sum of all values in barset.
             */
             qreal QBarSet::total()
             {
                 qreal total(0);
                 for (int i=0; i<mValues.count(); i++) {
                     total += mValues.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen pen)
             {
                 mPen = pen;
                 emit changed();
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return mPen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush brush)
             {
                 mBrush = brush;
                 emit changed();
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return mBrush;
             }
             /*!
                 Sets the pen for floating values that are drawn on top of this set
             */
             void QBarSet::setFloatingValuePen(const QPen pen)
             {
                 mFloatingValuePen = pen;
             }
             /*!
                 Returns the pen for floating values that are drawn on top of this set
             */
             QPen QBarSet::floatingValuePen() const
             {
                 return mFloatingValuePen;
             }
             /*!
                 \internal \a pos
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, mName);
                 emit hoverEnter(pos);
             }
             /*!
                 \internal
             */
             void QBarSet::barHoverLeaveEvent()
             {
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +29 -13

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_total(0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit added(slices);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 add(slice);
                 return *this;
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             void QPieSeries::insert(int i, QPieSlice* slice)
             {
                 Q_ASSERT(i <= m_slices.count());
                 slice->setParent(this);
                 m_slices.insert(i, slice);
                 updateDerivativeData();
                 connect(slice, SIGNAL(changed()), this, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = NULL;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = m_slices;
                 foreach (QPieSlice* s, m_slices) {
                     m_slices.removeOne(s);
                     delete s;
                 }
                 updateDerivativeData();
                 emit removed(slices);
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 return m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the center position of the pie by \a relativeHorizontalPosition and \a relativeVerticalPosition.
                 The factors are relative to the chart rectangle where:
                 \a relativeHorizontalPosition 0.0 means the absolute left.
                 \a relativeHorizontalPosition 1.0 means the absolute right.
                 \a relativeVerticalPosition 0.0 means the absolute top.
                 \a relativeVerticalPosition 1.0 means the absolute bottom.
                 By default both values are 0.5 which puts the pie in the middle of the chart rectangle.
                 \sa pieHorizontalPosition(), pieVerticalPosition(), setPieSize()
             */
             void QPieSeries::setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition)
             {
                 if (relativeHorizontalPosition < 0.0 || relativeHorizontalPosition > 1.0 ||
                         relativeVerticalPosition < 0.0 || relativeVerticalPosition > 1.0)
                     return;
                 if (m_pieRelativeHorPos != relativeHorizontalPosition || m_pieRelativeVerPos != relativeVerticalPosition) {
                     m_pieRelativeHorPos = relativeHorizontalPosition;
                     m_pieRelativeVerPos = relativeVerticalPosition;
                     emit piePositionChanged();
                 }
             }
             /*!
                 Gets the horizontal position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute left.
 .0 means the absolute right.
                 By default it is 0.5 which puts the pie in the horizontal middle of the chart rectangle.
                 \sa setPiePosition(), pieVerticalPosition(), setPieSize()
             */
             qreal QPieSeries::pieHorizontalPosition() const
             {
                 return m_pieRelativeHorPos;
             }
             /*!
                 Gets the vertical position position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute top.
 .0 means the absolute bottom.
                 By default it is 0.5 which puts the pie in the vertical middle of the chart rectangle.
                 \sa setPiePosition(), pieHorizontalPosition(), setPieSize()
             */
             qreal QPieSeries::pieVerticalPosition() const
             {
                 return m_pieRelativeVerPos;
             }
             /*!
                 Sets the relative size of the pie.
                 The \a relativeSize is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa pieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 if (relativeSize < 0.0 || relativeSize > 1.0)
                     return;
                 if (m_pieRelativeSize != relativeSize) {
                     m_pieRelativeSize = relativeSize;
                     emit pieSizeChanged();
                 }
             }
             /*!
                 Gets the relative size of the pie.
                 The size is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa setPieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             qreal QPieSeries::pieSize() const
             {
                 return m_pieRelativeSize;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be less than pie end angle. Default value is 0.
                 \sa pieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieStartAngle && angle <= m_pieEndAngle) {
                     m_pieStartAngle = angle;
                     updateDerivativeData();
                 }
             }
             /*!
                 Gets the start angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock. Default value is 360.
                 \sa setPieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             qreal QPieSeries::pieStartAngle() const
             {
                 return m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieEndAngle && angle >= m_pieStartAngle) {
                     m_pieEndAngle = angle;
                     updateDerivativeData();
                 }
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 return m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue()
             */
             qreal QPieSeries::total() const
             {
                 return m_total;
             }
             /*!
                 \fn void QPieSeries::changed()
                 This signal emitted when something has changed in the series.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // nothing to show..
                 if (m_total == 0)
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     bool isChanged = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         isChanged = true;
                     }
                     qreal sliceSpan = pieSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         isChanged = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         isChanged = true;
                     }
                     sliceAngle += sliceSpan;
                     if (isChanged)
                         changed << s;
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     emit s->changed();
             }
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
-                    disconnect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), 0, 0);
+                    disconnect(m_model, 0, this, 0);
-                    disconnect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), 0, 0);
+                    m_mapValues = -1;
-                    disconnect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), 0, 0);
+                    m_mapLabels = -1;
+                    m_mapOrientation = Qt::Vertical;
                 }
-                // set new model if not NULL and connect necessary signals from it
+                // set new model
                 if(model)
                 {
                     m_model = model;
-                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
-                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
-                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                     return true;
                 }
+                else
+                {
+                    m_model = NULL;
+                    return false;
+                }
+            }
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
+                if (m_model == NULL)
+                    return;
                 m_mapValues = modelValuesLine;
                 m_mapLabels = modelLabelsLine;
                 m_mapOrientation = orientation;
-                if (m_model == NULL)
+                // connect the signals
-                    return;
+                if (m_mapOrientation == Qt::Vertical)
+                {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
+                else
+                {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
+                // create the initial slices set
                 if (m_mapOrientation == Qt::Vertical)
                     for (int i = 0; i < m_model->rowCount(); i++)
                         add(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
                 else
                     for (int i = 0; i < m_model->columnCount(); i++)
                         add(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
             }
             void QPieSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        slices().at(topLeft.row())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         slices().at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                     else if (topLeft.column() == m_mapLabels)
                         slices().at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     //        slices().at(topLeft.column())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
-                    if (topLeft.column() == m_mapValues)
+                    if (topLeft.row() == m_mapValues)
                         slices().at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
-                    else if (topLeft.column() == m_mapLabels)
+                    else if (topLeft.row() == m_mapLabels)
                         slices().at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 insert(start, newSlice);
             }
             void QPieSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 remove(slices().at(start));
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +33 -5

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
             {
                 m_mapX = -1;
                 m_mapY = -1;
                 m_mapOrientation = Qt::Vertical;
                 //    m_mapYOrientation = Qt::Vertical;
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QPointF& point)
             {
                 add(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     add(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF& point)
             {
                 replace(point.x(),point.y());
             }
             /*!
               Removes first \a x value and related y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 int index = m_x.indexOf(x);
                 if(index==-1) return;
                 m_x.remove(index);
                 m_y.remove(index);
                 emit pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 int index =-1;
                 do{
                     index = m_x.indexOf(x,index+1);
                 }while(index !=-1 && m_y.at(index)!=y);
                 if(index==-1) return;
                 m_x.remove(index);
                 m_y.remove(index);
                 emit pointRemoved(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
                 remove(point.x(),point.y());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapX, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapY, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // data is in a column, so return the number of items in single column
                         return m_model->rowCount();
                     else
                         // data is in a row, so return the number of items in single row
                         return m_model->columnCount();
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 QList<QPointF> data;
                 for (int i(0); i < m_x.count() && i < m_y.count(); i++)
                     data.append(QPointF(m_x.at(i), m_y.at(i)));
                 return data;
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
                     m_pen=pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setBrush(const QBrush& brush)
             {
                 if(brush!=m_brush){
                     m_brush=brush;
                     emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 add(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 add(points);
                 return *this;
             }
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                     emit pointReplaced(topLeft.row());
                 else
                     emit pointReplaced(topLeft.column());
             }
             void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 emit pointAdded(start);
             }
             void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 emit pointRemoved(start);
             }
             bool QXYSeries::setModel(QAbstractItemModel* model) {
+                // disconnect signals from old model
+                if(m_model)
+                {
+                    disconnect(m_model, 0, this, 0);
+                    m_mapX = -1;
+                    m_mapY = -1;
+                    m_mapOrientation = Qt::Vertical;
+                }
+                // set new model
+                if(model)
+                {
                     m_model = model;
-                //    for (int i = 0; i < m_model->rowCount(); i++)
-                //        emit pointAdded(i);
-                connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
-                connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
-                connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                     return true;
                 }
+                else
+                {
+                    m_model = NULL;
+                    return false;
+                }
+            }
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
+                if (m_model == NULL)
+                    return;
                 m_mapX = modelX;
                 m_mapY = modelY;
                 m_mapOrientation = orientation;
+                if (m_mapOrientation == Qt::Vertical)
+                {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
+                else
+                {
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
             }
             //void QXYSeries::setModelMappingY(int modelLineIndex, Qt::Orientation orientation)
             //{
             //    m_mapY = modelLineIndex;
             //    m_mapYOrientation = orientation;
             //}
             #include "moc_qxyseries.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