HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r519:987444b37af4

Table model data example

Marek Rosa -

r519:987444b37af4

parent child

Context file:

r519:987444b37af4

Collapse all files

examples/tablemodelchart/customtablemodel.cpp created 644 +123 0

@@ -0,0 +1,123
	1	#include "customtablemodel.h"
	2
	3	CustomTableModel::CustomTableModel(QObject *parent) :
	4	QAbstractTableModel(parent)
	5	{
	6	m_points.append(QPointF(10, 50));
	7	m_labels.append("Apples");
	8	m_points.append(QPointF(60, 70));
	9	m_labels.append("Oranges");
	10	m_points.append(QPointF(110, 50));
	11	m_labels.append("Bananas");
	12	m_points.append(QPointF(140, 40));
	13	m_labels.append("Lemons");
	14	m_points.append(QPointF(200, 150));
	15	m_labels.append("Plums");
	16	}
	17
	18	int CustomTableModel::rowCount(const QModelIndex & parent) const
	19	{
	20	return m_points.count();
	21	}
	22
	23	int CustomTableModel::columnCount(const QModelIndex & parent) const
	24	{
	25	return 3;
	26	}
	27
	28	QVariant CustomTableModel::headerData (int section, Qt::Orientation orientation, int role ) const
	29	{
	30	if (role != Qt::DisplayRole)
	31	return QVariant();
	32
	33	if (orientation == Qt::Horizontal)
	34	{
	35	switch(section)
	36	{
	37	case 0:
	38	return "x";
	39	case 1:
	40	return "y";
	41	case 2:
	42	return "Fruit";
	43	default: "What?";
	44	}
	45	}
	46	else
	47	return QString("%1").arg(section + 1);
	48	}
	49
	50	QVariant CustomTableModel::data(const QModelIndex & index, int role) const
	51	{
	52	if (role == Qt::DisplayRole)
	53	{
	54	switch(index.column())
	55	{
	56	case 0:
	57	return m_points[index.row()].x();
	58	case 1:
	59	return m_points[index.row()].y();
	60	case 2:
	61	return m_labels[index.row()];
	62	default:
	63	return QVariant();
	64	}
	65	}
	66	else if (role == Qt::EditRole)
	67	{
	68	switch(index.column())
	69	{
	70	case 0:
	71	return m_points[index.row()].x();
	72	case 1:
	73	return m_points[index.row()].y();
	74	case 2:
	75	return m_labels[index.row()];
	76	default:
	77	return QVariant();
	78	}
	79	}
	80	}
	81
	82	bool CustomTableModel::setData ( const QModelIndex & index, const QVariant & value, int role)
	83	{
	84	if (index.isValid() && role == Qt::EditRole)
	85	{
	86	switch(index.column())
	87	{
	88	case 0:
	89	m_points[index.row()].setX(value.toDouble());
	90	break;
	91	case 1:
	92	m_points[index.row()].setY(value.toDouble());
	93	break;
	94	case 2:
	95	m_labels.replace(index.row(), value.toString());
	96	break;
	97	default:
	98	return false;
	99	}
	100	emit dataChanged(index, index);
	101	return true;
	102	}
	103	return false;
	104	}
	105
	106	Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
	107	{
	108	if (!index.isValid())
	109	return Qt::ItemIsEnabled;
	110	return QAbstractItemModel::flags(index) \| Qt::ItemIsEditable;
	111	}
	112
	113	bool CustomTableModel::insertRows ( int row, int count, const QModelIndex & parent)
	114	{
	115	beginInsertRows(QModelIndex(), row /dataTable.count()/, row + count - 1);
	116	for (int i = 0; i < count; i++)
	117	{
	118	m_points.append(QPointF());
	119	m_labels.append("");
	120	}
	121	endInsertRows();
	122	return true;
	123	}

examples/tablemodelchart/customtablemodel.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef XYPOINTSMODEL_H
	2	#define XYPOINTSMODEL_H
	3
	4	#include <QAbstractTableModel>
	5	#include <QPointF>
	6	#include <QStringList>
	7
	8	class CustomTableModel : public QAbstractTableModel
	9	{
	10	Q_OBJECT
	11	public:
	12	explicit CustomTableModel(QObject *parent = 0);
	13
	14	int rowCount ( const QModelIndex & parent = QModelIndex() ) const;
	15	int columnCount ( const QModelIndex & parent = QModelIndex() ) const;
	16	QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
	17	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
	18	bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
	19	Qt::ItemFlags flags ( const QModelIndex & index ) const;
	20	bool insertRows ( int row, int count, const QModelIndex & parent = QModelIndex() );
	21
	22	//signals:
	23
	24	//public slots:
	25	private:
	26	QList<QPointF> m_points;
	27	QStringList m_labels;
	28
	29
	30	};
	31
	32	#endif // XYPOINTSMODEL_H

examples/tablemodelchart/main.cpp created 644 +11 0

@@ -0,0 +1,11
	1	#include <QtGui/QApplication>
	2	#include "tablewidget.h"
	3
	4	int main(int argc, char *argv[])
	5	{
	6	QApplication a(argc, argv);
	7	TableWidget w;
	8	w.show();
	9
	10	return a.exec();
	11	}

examples/tablemodelchart/tablemodelchart.pro created 644 +22 0

@@ -0,0 +1,22
	1	#-------------------------------------------------
	2	#
	3	# Project created by QtCreator 2012-03-08T14:30:24
	4	#
	5	#-------------------------------------------------
	6
	7	!include( ../examples.pri ) {
	8	error( "Couldn't find the examples.pri file!" )
	9	}
	10
	11	QT += core gui
	12
	13	TARGET = tablemodelchart
	14	TEMPLATE = app
	15
	16
	17	SOURCES += main.cpp\
	18	tablewidget.cpp \
	19	customtablemodel.cpp
	20
	21	HEADERS += tablewidget.h \
	22	customtablemodel.h

examples/tablemodelchart/tablewidget.cpp created 644 +54 0

@@ -0,0 +1,54
	1	#include "tablewidget.h"
	2	#include <QGridLayout>
	3	#include <QTableView>
	4	#include <QStyledItemDelegate>
	5	#include "qlineseries.h"
	6	#include "qsplineseries.h"
	7	#include "customtablemodel.h"
	8	#include "qpieseries.h"
	9
	10	TableWidget::TableWidget(QWidget *parent)
	11	: QWidget(parent)
	12	{
	13
	14
	15	// create simple model for storing data
	16	// user's table data model
	17	CustomTableModel* model = new CustomTableModel;
	18	QTableView* tableView = new QTableView;
	19	tableView->setModel(model);
	20	tableView->setMinimumSize(340, 480);
	21	// tableView->setItemDelegate(new QStyledItemDelegate);
	22	chartView = new QChartView;
	23	chartView->setMinimumSize(640, 480);
	24
	25	// create
	26	// QLineSeries* series = new QLineSeries;
	27	QSplineSeries* series = new QSplineSeries;
	28	series->setModel(model);
	29	series->setModelMappingX(0);
	30	series->setModelMappingY(1);
	31
	32	// series->add(QPointF(150, 100));
	33	// series->add(QPointF(200, 130));
	34	// series->add(QPointF(250, 120));
	35	// series->add(QPointF(300, 140));
	36	// series->add(QPointF(350, 160));
	37
	38	// QPieSeries* pieSeries = new QPieSeries;
	39	// pieSeries->setModel(model);
	40	// pieSeries
	41
	42	chartView->addSeries(series);
	43
	44	// create main layout
	45	QGridLayout* mainLayout = new QGridLayout;
	46	mainLayout->addWidget(tableView, 1, 1);
	47	mainLayout->addWidget(chartView, 1, 2);
	48	setLayout(mainLayout);
	49	}
	50
	51	TableWidget::~TableWidget()
	52	{
	53
	54	}

examples/tablemodelchart/tablewidget.h created 644 +23 0

@@ -0,0 +1,23
	1	#ifndef TABLEWIDGET_H
	2	#define TABLEWIDGET_H
	3
	4	#include <QtGui/QWidget>
	5	#include "qchartview.h"
	6
	7	QTCOMMERCIALCHART_USE_NAMESPACE
	8
	9	class TableWidget : public QWidget
	10	{
	11	Q_OBJECT
	12
	13	public:
	14	TableWidget(QWidget *parent = 0);
	15	~TableWidget();
	16
	17
	18
	19	private:
	20	QChartView* chartView;
	21	};
	22
	23	#endif // TABLEWIDGET_H

examples/examples.pro +2 -3

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

src/splinechart/qsplineseries.cpp +21 -15

             #include "qsplineseries.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
             */
             /*!
               \fn QSeriesType QSplineSeries::type() const
               Returns the type of the series
               */
             /*!
               \fn QSeriesType QSplineSeries::controlPoint(int index) const
               Returns the control point specified by \a index
               */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transfered.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(parent)
             {
                 connect(this,SIGNAL(pointAdded(int)), this, SLOT(updateControlPoints()));
                 connect(this,SIGNAL(pointRemoved(int)), this, SLOT(updateControlPoints()));
                 connect(this,SIGNAL(pointReplaced(int)), this, SLOT(updateControlPoints()));
             }
             /*!
               \internal
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeries::calculateControlPoints()
             {
                 // Based on http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit
                 // CPOL License
-                int n = m_x.size() - 1;
+                int n = count() - 1;
                 if (n == 1)
                 { // Special case: Bezier curve should be a straight line.
                     //            firstControlPoints = new Point[1];
                     // 3P1 = 2P0 + P3
-                    m_controlPoints.append(QPointF((2 * m_x[0] + m_x[1]) / 3, (2 * m_y[0] + m_y[1]) / 3));
+                    m_controlPoints.append(QPointF((2 * x(0) + x(1)) / 3, (2 * y(0) + y(1)) / 3));
                     // P2 = 2P1  P0
-                    m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - m_x[0], 2 * m_controlPoints[0].y() - m_y[0]));
+                    m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - x(0), 2 * m_controlPoints[0].y() - y(0)));
                     return;
                 }
                 // Calculate first Bezier control points
                 // Right hand side vector
                 //  Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QList<qreal> rhs;
-                rhs.append(m_x[0] + 2 * m_x[1]);
+                rhs.append(x(0) + 2 * x(1));
                 // Set right hand side X values
                 for (int i = 1; i < n - 1; ++i)
-                    rhs.append(4 * m_x[i] + 2 * m_x[i + 1]);
+                    rhs.append(4 * x(i) + 2 * x(i + 1));
-                rhs.append((8 * m_x[n - 1] + m_x[n]) / 2.0);
+                rhs.append((8 * x(n - 1) + x(n)) / 2.0);
                 // Get first control points X-values
-                QList<qreal> x = getFirstControlPoints(rhs);
+                QList<qreal> xControl = getFirstControlPoints(rhs);
-                rhs[0] = m_y[0] + 2 * m_y[1];
+                rhs[0] = y(0) + 2 * y(1);
                 // Set right hand side Y values
                 for (int i = 1; i < n - 1; ++i)
-                    rhs[i] = 4 * m_y[i] + 2 * m_y[i + 1];
+                    rhs[i] = 4 * y(i) + 2 * y(i + 1);
-                rhs[n - 1] = (8 * m_y[n - 1] + m_y[n]) / 2.0;
+                rhs[n - 1] = (8 * y(n - 1) + y(n)) / 2.0;
                 // Get first control points Y-values
-                QList<qreal> y = getFirstControlPoints(rhs);
+                QList<qreal> yControl = getFirstControlPoints(rhs);
                 // Fill output arrays.
                 for (int i = 0; i < n; ++i)
                 {
                     // First control point
-                    m_controlPoints.append(QPointF(x[i], y[i]));
+                    m_controlPoints.append(QPointF(xControl[i], yControl[i]));
                     // Second control point
                     if (i < n - 1)
-                        m_controlPoints.append(QPointF(2 * m_x[i + 1] - x[i + 1], 2 * m_y[i + 1] - y[i + 1]));
+                        m_controlPoints.append(QPointF(2 * x(i + 1) - xControl[i + 1], 2 * y(i + 1) - yControl[i + 1]));
                     else
-                        m_controlPoints.append(QPointF((m_x[n] + x[n - 1]) / 2, (m_y[n] + y[n - 1]) / 2));
+                        m_controlPoints.append(QPointF((x(n) + xControl[n - 1]) / 2, (y(n) + yControl[n - 1]) / 2));
                 }
             }
             /*!
               \internal
               */
             QList<qreal> QSplineSeries::getFirstControlPoints(QList<qreal> rhs)
             {
                 QList<qreal> x; // Solution vector.
                 QList<qreal> tmp; // Temp workspace.
                 qreal b = 2.0;
                 x.append(rhs[0] / b);
                 tmp.append(0);
                 for (int i = 1; i < rhs.size(); i++) // Decomposition and forward substitution.
                 {
                     tmp.append(1 / b);
                     b = (i < rhs.size() - 1 ? 4.0 : 3.5) - tmp[i];
                     x.append((rhs[i] - x[i - 1]) / b);
                 }
                 for (int i = 1; i < rhs.size(); i++)
                     x[rhs.size() - i - 1] -= tmp[rhs.size() - i] * x[rhs.size() - i]; // Backsubstitution.
                 return x;
             }
             /*!
               \internal
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeries::updateControlPoints()
             {
-                if(m_x.size() > 1)
+                if(count() > 1)
                 {
                     m_controlPoints.clear();
                     calculateControlPoints();
                 }
             }
+            bool QSplineSeries::setModel(QAbstractItemModel* model)
+            {
+                QXYSeries::setModel(model);
+                calculateControlPoints();
+            }
             #include "moc_qsplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +1 0

             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include "qchartglobal.h"
             #include <QtGlobal>
             #include "qlineseries.h"
             #include <QList>
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
             public:
                 QSplineSeries(QObject *parent = 0);
                 QSeriesType type() const {return QSeries::SeriesTypeSpline;}
             //    int count() const { return m_x.size(); }
                 QPointF controlPoint(int index) const {return m_controlPoints[index];}
+                bool setModel(QAbstractItemModel* model);
                 // TODO: allow the user to set custom control points
             //    void setCustomControlPoints(QList<QPointsF> controlPoints);
             //    bool calculateControlPointsAutomatically();
             //    void setCalculateControlPointsAutomatically();
             private:
                 void calculateControlPoints();
                 QList<qreal> getFirstControlPoints(QList<qreal> rhs);
             private slots:
                 void updateControlPoints();
             private:
                 QList<QPointF> m_controlPoints;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/xychart/qxyseries.cpp +31 -6

             #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::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_model = 0;
+                m_mapX = 0;
+                m_mapY = 1;
             }
             /*!
                 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());
+                replace(point.x(),point.y());
             }
             /*!
               Removes current \a x and y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 int index = m_x.indexOf(x);
                 emit pointRemoved(index);
                 m_x.remove(index);
                 m_y.remove(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
                 remove(point.x());
             }
             /*!
                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
             {
-               return m_x.at(pos);
+                if (m_model)
+                    return m_model->data(m_model->index(pos, m_mapX), Qt::DisplayRole).toDouble();
+                else
+                    return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
-               return m_y.at(pos);
+                if (m_model)
+                    return m_model->data(m_model->index(pos, m_mapY), Qt::DisplayRole).toDouble();
+                else
+                    return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
-            	Q_ASSERT(m_x.size() == m_y.size());
+                Q_ASSERT(m_x.size() == m_y.size());
-            	return m_x.size();
+            //    int k = m_model->rowCount();
+                if (m_model)
+                    return m_model->rowCount();
+                else
+                    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)
+            {
+                emit pointReplaced(topLeft.row());
+            }
+            bool QXYSeries::setModel(QAbstractItemModel* 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(), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+            }
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +14 0

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
                 Q_OBJECT
             protected:
                 QXYSeries(QObject* parent=0);
                 virtual ~QXYSeries();
             public:
                 void add(qreal x, qreal y);
                 void add(const QPointF& point);
                 void add(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF& point);
                 void remove(qreal x);
                 void remove(const QPointF& point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen& pen);
                 QPen pen() const {return m_pen;}
                 void setBrush(const QBrush& pen);
                 QBrush brush() const {return m_brush;}
+                bool setModel(QAbstractItemModel* model);
+                QAbstractItemModel* model() {return m_model;}
+                void setModelMappingX(int modelColumn) {m_mapX = modelColumn;}
+                void setModelMappingY(int modelColumn) {m_mapY = modelColumn;}
+                private slots:
+                    void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
             signals:
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
+                QAbstractItemModel* m_model;
+                int m_mapX;
+                int m_mapY;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychartitem.cpp +2 -2

             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChartItem::XYChartItem(QXYSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series)
             {
                 QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
             }
             QPointF XYChartItem::calculateGeometryPoint(const QPointF& point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (m_series->x(index) - m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
             void XYChartItem::updatePoints(QVector<QPointF>& points)
             {
                 setGeometry(points);
             }
             void XYChartItem::updatePoint(QVector<QPointF>& points)
             {
                 setGeometry(points);
             }
             void XYChartItem::setGeometry(QVector<QPointF>& points)
             {
                 m_points = points;
             }
             //handlers
             void XYChartItem::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
                 updatePoints(points);
                 update();
             }
             void XYChartItem::handlePointRemoved(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 updatePoints(points);
                 update();
             }
             void XYChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 m_points.replace(index,point);
-                updatePoint(points);
+                updatePoint(m_points);
                 update();
             }
             void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if(isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updatePoints(points);
                 update();
             }
             void XYChartItem::handleGeometryChanged(const QRectF& rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
-            	if(isEmpty()) return;
+                if(isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
             	updatePoints(points);
             	update();
             }
             bool XYChartItem::isEmpty()
             {
                return !m_clipRect.isValid() ||  m_maxX - m_minX == 0 || m_maxY - m_minY ==0 ;
             }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages