HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r940:7021ab6fbe7f

gdpbarchart moved to test. Few small doc fixes

Marek Rosa -

r940:7021ab6fbe7f

parent child

Context file:

r940:7021ab6fbe7f

Collapse all files

demos/demos.pro 0 -1

             TEMPLATE = subdirs
             SUBDIRS += chartthemes \
                        piechartcustomization \
-                       gdpbarchart \
                        qmlchart

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"
             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->append(0, 6);
                 series->append(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()
+                \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 transfered.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             QSeries::QSeriesType QAreaSeries::type() const
             {
                 return QSeries::SeriesTypeArea;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             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;
             }
             bool QAreaSeries::setModel(QAbstractItemModel* model)
             {
                 Q_UNUSED(model);
                 qWarning()<<"Not implemented";
                 return false;
             }
             QAbstractItemModel* QAreaSeries::model() const
             {
                 return 0;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q):QSeriesPrivate(q),
               m_upperSeries(upperSeries),
               m_lowerSeries(lowerSeries),
               m_pointsVisible(false)
             {
             };
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.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 "qbarset.h"
             #include "qbarset_p.h"
             #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, Qt::MouseButtons button)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
                 Parameter \a button mouse button
             */
             /*!
                 \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::showToolTip(QPoint pos, QString tip)
+                \fn void QBarSetPrivate::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)
                 ,d_ptr(new QBarSetPrivate(name,this))
             //    ,m_name(name)
             //    ,m_labelsVisible(false)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 d_ptr->m_values.append(value);
                 emit d_ptr->structureChanged();
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a i position.
                 The value that is currently at this postion is moved to postion i + 1
                 \sa removeValue()
             */
             void QBarSet::insertValue(int i, qreal value)
             {
                 d_ptr->m_values.insert(i, value);
             }
             /*!
                 Removes the value specified by \a i
                 \sa insertValue()
             */
             void QBarSet::removeValue(int i)
             {
                 d_ptr->m_values.removeAt(i);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
                 d_ptr->m_values.replace(index,value);
                 emit d_ptr->valueChanged();
             }
             /*!
                 Returns sum of all values in barset.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     total += d_ptr->m_values.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->valueChanged();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->valueChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a pen of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelPen(const QPen &pen)
             {
                 if(d_ptr->m_labelPen!=pen){
                     d_ptr->m_labelPen = pen;
                     emit d_ptr->valueChanged();
                 }
             }
             /*!
                 Returns pen of the values that are drawn on top of this barset
             */
             QPen QBarSet::labelPen() const
             {
                 return d_ptr->m_labelPen;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->valueChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->valueChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Sets visibility of bar labels. If \a visible is true, labels are drawn on top of barsets.
             */
             void QBarSet::setLabelsVisible(bool visible)
             {
                 if(d_ptr->m_labelsVisible!=visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->labelsVisibleChanged(visible);
                 }
             }
             /*!
                 Returns the visibility of values
             */
             bool QBarSet::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, m_name);
                 emit hoverEnter(pos);
             }
             */
             /*
             void QBarSet::barHoverLeaveEvent()
             {
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             */
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(QString name, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_name(name),
                 m_labelsVisible(false)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             //TODO: fixme , refactor it and get rid of it
             void QBarSetPrivate::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, m_name);
                 emit hoverEnter(pos);
             }
             //TODO: fixme , refactor it and get rid of it
             void QBarSetPrivate::barHoverLeaveEvent()
             {
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qseries.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 "qseries.h"
             #include "qseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QScatterSeries
             */
             /*!
                 \enum QSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \fn QSeries::QSeries(QObject *parent)
                 \brief Constructs ChartSeries object with \a parent.
             */
             /*!
                 \fn QSeries::~QSeries()
                 \brief Virtual destructor for the chart series.
             */
             /*!
                 \fn QSeriesType QSeries::type() const
                 \brief The type of the series.
             */
             /*!
                 \fn bool QSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
                 \fn QAbstractItemModel* QSeries::model() const
                 \brief Returns the pointer to the model that is used as the series data source
             */
             /*!
                 \property QSeries::name
                 \brief name of the series property
             */
             /*!
-                \fn void QSeries::setName(QString name)
+                \fn void QSeries::setName(const QString& name)
                 \brief Sets a \a name for the series.
                 The name of a series is shown in the legend for QXYSeries.
                 \sa QChart::setTitle()
                 \sa QPieSlice::setLabel()
                 \sa QBarSet::setName()
             */
             /*!
                 \fn QString QSeries::name() const
                 \brief Returns the name of the series.
                 \sa setName()
             */
             QSeries::QSeries(QObject *parent) : QObject(parent),
             d_ptr(new QSeriesPrivate(this))
             {
             }
             QSeries::QSeries(QSeriesPrivate &d,QObject *parent) : QObject(parent),
             d_ptr(&d)
             {
             }
             QSeries::~QSeries()
             {
             }
             QAbstractItemModel* QSeries::model() const
             {
                 return d_ptr->m_model;
             }
             void QSeries::setName(const QString& name)
             {
                 d_ptr->m_name = name;
             }
             QString QSeries::name() const
             {
                 return d_ptr->m_name;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QSeriesPrivate::QSeriesPrivate(QSeries* q): q_ptr(q),m_model(0)
             {
             }
             QSeriesPrivate::~QSeriesPrivate()
             {
             }
             #include "moc_qseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +4 -4

             /****************************************************************************
             **
             ** 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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include <QAbstractItemModel>
             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)
+                \fn void QXYSeriesPrivate::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
-                \fn void QXYSeries::pointAdded(int index)
+                \fn void QXYSeriesPrivate::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
-                \fn void QXYSeries::pointRemoved(int index)
+                \fn void QXYSeriesPrivate::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
-                \fn void QXYSeries::updated()
+                \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \fn int QXYSeries::mapFirst() const
                 Returns the index of the model's item that is used as a first one for the series.
                 \sa mapCount()
             */
             /*!
                 \fn int QXYSeries::mapCount() const
                 Returns the number of the items that are taken from the model.
                 If -1 it means all the items of the model following the first one are used.
                 \sa mapFirst()
             */
             /*!
                 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(*new QXYSeriesPrivate(this),parent)
             {
             }
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent):QSeries(d,parent)
             {
             }
             /*!
                 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::append(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 d->m_x<<x;
                 d->m_y<<y;
                 emit d->pointAdded(d->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::append(const QPointF &point)
             {
                 append(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::append(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     append(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 d->m_x[index] = x;
                 d->m_y[index] = y;
                 emit d->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)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 if (index == -1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index =-1;
                 do {
                     index = d->m_x.indexOf(x,index+1);
                 } while (index !=-1 && d->m_y.at(index)!=y);
                 if (index==-1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->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()
             {
                 Q_D(QXYSeries);
                 d->m_x.clear();
                 d->m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return d->m_model->data(d->m_model->index(d->m_mapX, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_x.at(pos);
                 }
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return d->m_model->data(d->m_model->index(d->m_mapY, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_y.at(pos);
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical) {
                         // data is in a column. Return the number of mapped items if the model's column have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapLimited)
                             return qMin(d->m_mapCount, qMax(d->m_model->rowCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->rowCount() - d->m_mapFirst, 0);
                     } else {
                         // data is in a row. Return the number of mapped items if the model's row have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapLimited)
                             return qMin(d->m_mapCount, qMax(d->m_model->columnCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->columnCount() - d->m_mapFirst, 0);
                     }
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return d->m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 Q_D(QXYSeries);
                 QList<QPointF> data;
                 for (int i(0); i < d->m_x.count() && i < d->m_y.count(); i++)
                     data.append(QPointF(d->m_x.at(i), d->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::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 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::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 append(points);
                 return *this;
             }
             /*!
                \internal
              */
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 Q_D(QXYSeries);
                 if (d->m_mapOrientation == Qt::Vertical) {
                     if (topLeft.row() >= d->m_mapFirst && (!d->m_mapLimited || topLeft.row() < d->m_mapFirst + d->m_mapCount))
                         emit d->pointReplaced(topLeft.row() - d->m_mapFirst);
                 } else {
                     if (topLeft.column() >= d->m_mapFirst && (!d->m_mapLimited || topLeft.column() < d->m_mapFirst + d->m_mapCount))
                         emit d->pointReplaced(topLeft.column() - d->m_mapFirst);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAboutToBeAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it and update is needed
                         // check how many mapped items there is currently (before new items are added)
                         // if the number of items currently is equal the m_mapCount then some needs to be removed from xychartitem
                         // internal storage before new ones can be added
                         int itemsToRemove = qMin(count() - qMax(start - d->m_mapFirst, 0), end - start + 1);
                         if (d->m_mapCount == count()) {
                             for (int i = 0; i < itemsToRemove; i++)
                                 emit d->pointRemoved(qMin(end, count()) - i);
                         }
                     }
                 } else {
                     // map is not limited (it includes all the items starting from m_mapFirst till the end of model)
                     // nothing to do
                     //        emit pointAdded(qMax(start - m_mapFirst, 0));
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it
                         // update needed
                         if (count() > 0) {
                             int toBeAdded = qMin(d->m_mapCount - (start - d->m_mapFirst), end - start + 1);
                             for (int i = 0; i < toBeAdded; i++)
                                 if (start + i >= d->m_mapFirst)
                                     emit d->pointAdded(start + i);
                         }
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit d->pointAdded(start + i);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAboutToBeRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the removed data is in the mapped area or before it
                         // update needed
                         // check how many items need to be removed from the xychartitem storage
                         // the number equals the number of items that are removed and that lay before
                         // or in the mapped area. Items that lay beyond the map do not count
                         // the max is the current number of items in storage (count())
                         int itemsToRemove = qMin(count(), qMin(end, d->m_mapFirst + d->m_mapCount - 1) - start + 1);
                         for (int i = 0; i < itemsToRemove; i++)
                             emit d->pointRemoved(start);
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit d->pointRemoved(start);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_D(QXYSeries);
                 // how many items there were before data was removed
                 //    int oldCount = count() - 1;
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // if the current items count in the whole model is bigger than the index of the last item
                         // that was removed than it means there are some extra items available
                         int removedItemsCount = qMin(count(), qMin(end, d->m_mapFirst + d->m_mapCount - 1) - start + 1);
                         int extraItemsAvailable = 0;
                         if (d->m_mapOrientation == Qt::Vertical) {
                             extraItemsAvailable = qMax(d->m_model->rowCount() + (end - start + 1) - qMax(end + 1, d->m_mapFirst + d->m_mapCount), 0);
                         } else {
                             extraItemsAvailable = qMax(d->m_model->columnCount() + (end - start + 1) - qMax(end + 1, d->m_mapFirst + d->m_mapCount), 0);
                         }
                         // if there are excess items available (below the mapped area) use them to repopulate mapped area
                         int toBeAdded = qMin(extraItemsAvailable, removedItemsCount);
                         for (int k = 0; k < toBeAdded; k++)
                             emit d->pointAdded(d->m_mapFirst + d->m_mapCount - removedItemsCount + k);
                     }
                 } else {
                     // data was removed from XYSeries interal storage. Nothing more to do
                 }
             }
             /*!
                  \fn bool QXYSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
                  \sa setModelMapping(), setModelMappingRange()
              */
             bool QXYSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QXYSeries);
                 // disconnect signals from old model
                 if (d->m_model) {
                     QObject::disconnect(d->m_model, 0, this, 0);
                     d->m_mapX = -1;
                     d->m_mapY = -1;
                     d->m_mapFirst = 0;
                     d->m_mapCount = 0;
                     d->m_mapLimited = false;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if (model) {
                     d->m_model = model;
                     return true;
                 } else {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation paramater specifies whether the data
                  is in columns or in rows.
                  \sa setModel(), setModelMappingRange()
              */
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 Q_D(QXYSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapX = modelX;
                 d->m_mapY = modelY;
                 d->m_mapFirst = 0;
                 d->m_mapOrientation = orientation;
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(d->m_model,SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(d->m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(d->m_model,SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(d->m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
             }
             /*!
                  \fn bool QXYSeries::setModelMappingRange(int first, int count)
                  Allows limiting the model mapping.
                  Parameter \a first specifies which element of the model should be used as a first one of the series.
                  Parameter \a count specifies how many elements should be mapped. If count is not specified (defaults to -1)
                  then all the items following \a first item in a model are used.
                  \sa setModel(), setModelMapping()
              */
             void QXYSeries::setModelMappingRange(int first, int count)
             {
                 Q_D(QXYSeries);
                 d->m_mapFirst = first;
                 if (count == 0) {
                     d->m_mapLimited = false;
                 } else {
                     d->m_mapCount = count;
                     d->m_mapLimited = true;
                 }
             }
             int QXYSeries::mapFirst() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapFirst;
             }
             int QXYSeries::mapCount() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapCount;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q): QSeriesPrivate(q),
             m_mapX(-1),
             m_mapY(-1),
             m_mapFirst(0),
             m_mapCount(0),
             m_mapLimited(false),
             m_mapOrientation( Qt::Vertical),
             m_pointsVisible(false)
             {
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

test/gdpbarchart/gdpData ~~demos/gdpbarchart/gdpData~~ renamed 0 0

	1	NO CONTENT: file renamed from demos/gdpbarchart/gdpData to test/gdpbarchart/gdpData			NO CONTENT: file renamed from demos/gdpbarchart/gdpData to test/gdpbarchart/gdpData

NO CONTENT: file renamed from demos/gdpbarchart/gdpData to test/gdpbarchart/gdpData

test/gdpbarchart/gdpbarchart.pro ~~demos/gdpbarchart/gdpbarchart.pro~~ renamed +3 -1

-            !include( ../demos.pri ):error( "Couldn't find the demos.pri file!" )
+            !include( ../test.pri ) {
+                error( "Couldn't find the test.pri file!" )
+            }
             QT+= sql
             TARGET = gdpbarchart
             SOURCES += main.cpp\
                     widget.cpp
             HEADERS  += widget.h
             !mac {
                 FILE = $$PWD/gdpData
                 win32:{FILE = $$replace(FILE, "/","\\")}
                 # TODO: QMAKE_POST_LINK does not work on mac; how to copy the data file?
                 QMAKE_POST_LINK += $$QMAKE_COPY $$FILE $$CHART_BUILD_BIN_DIR
             }

test/gdpbarchart/main.cpp ~~demos/gdpbarchart/main.cpp~~ renamed 0 0

NO CONTENT: file renamed from demos/gdpbarchart/main.cpp to test/gdpbarchart/main.cpp

test/gdpbarchart/widget.cpp ~~demos/gdpbarchart/widget.cpp~~ renamed 0 0

NO CONTENT: file renamed from demos/gdpbarchart/widget.cpp to test/gdpbarchart/widget.cpp

test/gdpbarchart/widget.h ~~demos/gdpbarchart/widget.h~~ renamed 0 0

NO CONTENT: file renamed from demos/gdpbarchart/widget.h to test/gdpbarchart/widget.h

test/test.pro +2 -1

             TEMPLATE = subdirs
             SUBDIRS += \
                 chartwidgettest \
-                wavechart
+                wavechart \
+                gdpbarchart
             !win32:{
                 SUBDIRS += auto
             }

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