HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1351:e5c3ac6bb1ee

random doc updates

Jani Honkonen -

r1351:e5c3ac6bb1ee

parent child

Context file:

r1351:e5c3ac6bb1ee

Collapse all files

src/areachart/qareaseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.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.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                \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::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::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 transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
-                Constructs area series object without upper or lower series.
+                Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++)
                     {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimator(presenter->animator());
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
                         area->lowerLineItem()->setAnimator(presenter->animator());
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxiscategories.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qaxiscategories.h"
             #include "qaxiscategories_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAxisCategories
                 \brief The QAxisCategoriess class is used for manipulating axis's categories.
                 \mainclass
                 Each axis can have categories instead of numerical representation. The typical use case
                 is bar chart, where categories are always show on X axis.
             */
             QAxisCategories::QAxisCategories():
             d_ptr(new QAxisCategoriesPrivate(this))
             {
             }
+            /*!
+              Destroys the object.
+            */
             QAxisCategories::~QAxisCategories()
             {
             }
             /*!
               Inserts \a categories to axis. First item in list is assumed to be at x = 0, next at x = 1 and so on
              */
             void QAxisCategories::insert(const QStringList &categories)
             {
                 int i=0;
                 foreach (const QString& string , categories) {
                     d_ptr->m_map.insert(i,string);
                     i++;
                 }
                 emit d_ptr->updated();
             }
             /*!
               Inserts category, instead of \a value on axis a \a label will be shown.
              */
             void QAxisCategories::insert(qreal value,QString label)
             {
                 d_ptr->m_map.insert(value,label);
                 emit d_ptr->updated();
             }
             /*!
               Removes category for \a value.
              */
             void QAxisCategories::remove(qreal value)
             {
                 d_ptr->m_map.remove(value);
                 emit d_ptr->updated();
             }
             /*!
               Removes all categories.
              */
             void QAxisCategories::clear()
             {
                 d_ptr->m_map.clear();
                 emit d_ptr->updated();
             }
             /*!
               Returns number of categories.
              */
             int QAxisCategories::count()
             {
                 return d_ptr->m_map.count();
             }
             /*!
               Returns all values of categories.
              */
             QList<qreal> QAxisCategories::values() const
             {
                 return d_ptr->m_map.keys();
             }
             /*!
               Returns label for given \a value.
              */
             QString QAxisCategories::label(qreal value) const
             {
                 return d_ptr->m_map.value(value);
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAxisCategoriesPrivate::QAxisCategoriesPrivate(QAxisCategories *q):
             q_ptr(q)
             {
             }
             QAxisCategoriesPrivate::~QAxisCategoriesPrivate()
             {
             }
             #include "moc_qaxiscategories.cpp"
             #include "moc_qaxiscategories_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.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.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
               \fn QSeriesType QSplineSeries::type() const
               Returns the type of the series
               */
             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 transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
                 Q_D(QSplineSeries);
                 QObject::connect(this,SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), d, SLOT(updateControlPoints()));
             }
+            /*!
+              Destroys the object.
+            */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 const QList<QPointF>& points = q->points();
                 int n = points.count() - 1;
                 if (n == 1)
                 {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
                     m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
                     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         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i){
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 }
                 vector[n - 1] = (8 * points[n-1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 }
                 vector[n - 1] = (8 * points[n-1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0,j =0; i < n; ++i, ++j) {
                     m_controlPoints[j].setX(xControl[i]);
                     m_controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1){
                         m_controlPoints[j].setX(2 * points[i+1].x() - xControl[i + 1]);
                         m_controlPoints[j].setY(2 * points[i+1].y() - yControl[i + 1]);
                     }else{
                         m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
             }
             QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i]=(vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             QPointF QSplineSeriesPrivate::controlPoint(int index) const
             {
                 //    Q_D(const QSplineSeries);
                 //    return d->m_controlPoints[index];
                 return m_controlPoints[index];
             }
             /*!
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.resize(2*q->count()-2);
                     calculateControlPoints();
                 }
             }
             Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     spline->setAnimator(presenter->animator());
                     spline->setAnimation(new SplineAnimation(spline));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_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