HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r467:bda5257e118d

Spline series windows compilation fix

Michal Klocek -

r467:bda5257e118d

parent child

Context file:

r467:bda5257e118d

Collapse all files

src/linechart/qlineseries.cpp +1 -24

             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn QPen QLineSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn bool  QLineSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QLineSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QLineSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QLineSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QLineSeries::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.
             */
-            QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent),
+            QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent)
-            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.
             */
             QLineSeries::~QLineSeries()
             {
             }
-            /*!
-                Sets \a pen used for drawing given series..
-            */
-            void QLineSeries::setPen(const QPen& pen)
-                if(pen!=m_pen){
-                m_pen=pen;
-                emit updated();
-            /*!
-                Sets if data points are \a visible and should be drawn on line.
-            */
-            void QLineSeries::setPointsVisible(bool visible)
-                if(m_pointsVisible!=visible){
-                m_pointsVisible=visible;
-                emit updated();
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +1 -9

             #ifndef QLINESERIES_H_
             #define QLINESERIES_H_
             #include "qchartglobal.h"
             #include "qxyseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
             	Q_OBJECT
             public:
             	QLineSeries(QObject* parent=0);
             	virtual ~QLineSeries();
             public: // from QChartSeries
             	virtual QSeriesType type() const {return QSeries::SeriesTypeLine;}
-            	void setPen(const QPen& pen);
-            	QPen pen() const {return m_pen;}
-            	void setPointsVisible(bool visible);
-            	bool pointsVisible() const {return m_pointsVisible;}
                 friend QDebug operator<< (QDebug d, const QLineSeries series);
-            private:
-            	QPen m_pen;
-            	bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/splinechart/qsplineseries.cpp +1 -1

             #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)
+                QXYSeries(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;
                 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));
                     // P2 = 2P1  P0
                     m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - m_x[0], 2 * m_controlPoints[0].y() - m_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]);
                 // 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((8 * m_x[n - 1] + m_x[n]) / 2.0);
                 // Get first control points X-values
                 QList<qreal> x = getFirstControlPoints(rhs);
                 rhs[0] = m_y[0] + 2 * m_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[n - 1] = (8 * m_y[n - 1] + m_y[n]) / 2.0;
                 // Get first control points Y-values
                 QList<qreal> y = getFirstControlPoints(rhs);
                 // Fill output arrays.
                 for (int i = 0; i < n; ++i)
                 {
                     // First control point
                     m_controlPoints.append(QPointF(x[i], y[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]));
                     else
                         m_controlPoints.append(QPointF((m_x[n] + x[n - 1]) / 2, (m_y[n] + y[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)
                 {
                     m_controlPoints.clear();
                     calculateControlPoints();
                 }
             }
             #include "moc_qsplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +10 -9

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

src/xychart/qxyseries.cpp +25 -1

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QXYSeries* series = new QXYSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QXYSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn bool  QXYSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \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)
+            QXYSeries::QXYSeries(QObject* parent):QSeries(parent),
+            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.
             */
             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());
             }
             /*!
               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 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());
             }
             /*!
               Clears all the data.
             */
             void QXYSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             /*!
+                Sets \a pen used for drawing given series..
+            */
+            void QXYSeries::setPen(const QPen& pen)
+            {
+                if(pen!=m_pen){
+                m_pen=pen;
+                emit updated();
+                }
+            }
+            /*!
+                Sets if data points are \a visible and should be drawn on line.
+            */
+            void QXYSeries::setPointsVisible(bool visible)
+            {
+                if(m_pointsVisible!=visible){
+                m_pointsVisible=visible;
+                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;
             }
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +9 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
             public:
             	QXYSeries(QObject* parent=0);
             	virtual ~QXYSeries();
             public:
             	void add(qreal x, qreal y);
             	void add(const QPointF& point);
             	void replace(qreal x,qreal y);
             	void replace(const QPointF& point);
             	void remove(qreal x);
             	void remove(const QPointF& point);
             	void clear();
             	int count() const;
             	qreal x(int pos) const;
             	qreal y(int pos) const;
             	QXYSeries& operator << (const QPointF &point);
+            	void setPen(const QPen& pen);
+            	QPen pen() const {return m_pen;}
+            	void setPointsVisible(bool visible);
+            	bool pointsVisible() const {return m_pointsVisible;}
             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;
+            	bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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