HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1638:039a92a11dcb

Various docs fixes

Marek Rosa -

r1638:039a92a11dcb

parent child

Context file:

r1638:039a92a11dcb

Collapse all files

src/axis/qbarcategoriesaxis.cpp +6 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 "qbarcategoriesaxis.h"
             #include "qbarcategoriesaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarCategoriesAxis
                 \brief The QBarCategoriesAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QBarCategoriesAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: "Feb"
                         axisX.max: "Jun"
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList Axis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QBarCategoriesAxis::minChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QBarCategoriesAxis::maxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QBarCategoriesAxis::rangeChanged(const QString &min, const QString &max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
                 QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
             {
             }
+            /*!
+                Destroys the object
+            */
             QBarCategoriesAxis::~QBarCategoriesAxis()
             {
             }
+            /*!
+                \internal
+            */
             QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QBarCategoriesAxis::append(const QStringList &categories)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.append(categories);
                 	setRange(categories.first(),categories.last());
                 }else{
                 	d->m_categories.append(categories);
                 }
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QBarCategoriesAxis::append(const QString &category)
             {
             	Q_D(QBarCategoriesAxis);
             	if (d->m_categories.isEmpty()) {
             		d->m_categories.append(category);
             		setRange(category,category);
             	}else{
             		d->m_categories.append(category);
             	}
             	emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QBarCategoriesAxis::remove(const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     setRange(d->m_categories.first(),d->m_categories.last());
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QBarCategoriesAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.insert(index,category);
                 	setRange(category,category);
                 }else{
                 }
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
             void QBarCategoriesAxis::clear()
             {
                 Q_D(QBarCategoriesAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit categoriesChanged();
             }
             void QBarCategoriesAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoriesAxis);
                 if(d->m_categories!=categories){
                 d->m_categories = categories;
                 setRange(categories.first(),categories.last());
                 emit categoriesChanged();
                 }
             }
             QStringList QBarCategoriesAxis::categories()
             {
                 Q_D(QBarCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QBarCategoriesAxis::count() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QBarCategoriesAxis::at(int index) const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
             void QBarCategoriesAxis::setMin(const QString& min)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QBarCategoriesAxis::min() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
             void QBarCategoriesAxis::setMax(const QString& max)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
             QString QBarCategoriesAxis::max() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
                 Q_D(QBarCategoriesAxis);
                 int minIndex = d->m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = d->m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 if (maxIndex <= minIndex) {
                     // max must be greater than min
                     return;
                 }
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - (minIndex))) {
                 	d->m_minCategory = minCategory;
                     d->m_min = minIndex;
                     emit minChanged(minCategory);
                     changed = true;
                 }
                 if (!qFuzzyIsNull(d->m_max - (maxIndex))) {
                     d->m_max = maxIndex;
                     d->m_maxCategory = maxCategory;
                     emit maxChanged(maxCategory);
                     changed = true;
                 }
                 if ((changed)) {
                     d->emitRange();
                     emit categoriesChanged();
                 }
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QBarCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
             QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
             {
             }
             void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
             void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
             void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QBarCategoriesAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
             int QBarCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QBarCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
             ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q( QBarCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             void QBarCategoriesAxisPrivate::emitRange()
             {
             	Q_Q( QBarCategoriesAxis);
             	if(!q->signalsBlocked()) {
             		emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false);
             	}
             }
             #include "moc_qbarcategoriesaxis.cpp"
             #include "moc_qbarcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qintervalaxis.cpp +6 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 "qintervalaxis.h"
             #include "qintervalaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QIntervalAxis
                 \brief The QIntervalAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QIntervalAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                 // TODO :)
                 \endcode
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QIntervalAxis::QIntervalAxis(QObject *parent):
                 QValuesAxis(*new QIntervalAxisPrivate(this),parent)
             {
             }
+            /*!
+                Destroys the object
+            */
             QIntervalAxis::~QIntervalAxis()
             {
             }
+            /*!
+                \internal
+            */
             QIntervalAxis::QIntervalAxis(QIntervalAxisPrivate &d,QObject *parent):QValuesAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QIntervalAxis::append(const QString& category, qreal x)
             {
                 Q_D(QIntervalAxis);
                 if (!d->m_categories.contains(category))
                 {
                 	if(d->m_categories.isEmpty()){
                 		Range range(d->m_categoryMinimum,x);
                 		d->m_categoriesMap.insert(category,range);
                 		d->m_categories.append(category);
                 	}else{
                 		Range range = d->m_categoriesMap.value(d->m_categories.last());
                 		d->m_categoriesMap.insert(category,Range(range.first,x));
                 		d->m_categories.append(category);
                 	}
                 	setRange(d->m_min,x);
                 }
             }
             void QIntervalAxis::setFisrtCategoryMinimum(qreal x)
             {
             	 Q_D(QIntervalAxis);
             	 if(d->m_categories.isEmpty()){
             		 d->m_categoryMinimum=x;
             	 }else{
             		 Range range = d->m_categoriesMap.value(d->m_categories.first());
             		 d->m_categoriesMap.insert(d->m_categories.first(),Range(x,range.second));
             		 setRange(x,d->m_min);
             	 }
             }
             /*!
                 Removes \a category from axis
             */
             void QIntervalAxis::remove(const QString &category)
             {
             	Q_UNUSED(category);
             	//TODO
             }
             QStringList QIntervalAxis::categories()
             {
                 Q_D(QIntervalAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QIntervalAxis::count() const
             {
                 Q_D(const QIntervalAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QIntervalAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QIntervalAxisPrivate::QIntervalAxisPrivate(QIntervalAxis* q):
                 QValuesAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
             QIntervalAxisPrivate::~QIntervalAxisPrivate()
             {
             }
             int QIntervalAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QIntervalAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
             ChartAxis* QIntervalAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
             	Q_UNUSED(presenter);
                // Q_Q( QCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return 0;
                 }else{
                     return 0;
                 }
             }
             #include "moc_qintervalaxis.cpp"
             #include "moc_qintervalaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qvaluesaxis.cpp +6 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 "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "chartvaluesaxisx_p.h"
             #include "chartvaluesaxisy_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QValuesAxis
                 \brief The Axis element is used for manipulating chart's axes
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int Axis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool Axis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
+            /*!
+                \internal
+            */
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
+            /*!
+                Destroys the object
+            */
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                 	d->emitRange();
                     emit rangeChanged(d->m_min,d->m_max);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
             void QValuesAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValuesAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValuesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValuesAxisY(q,presenter);
                 }else{
                     return new ChartValuesAxisX(q,presenter);
                 }
             }
             void QValuesAxisPrivate::emitRange()
             {
             	Q_Q(QValuesAxis);
             	if(!q->signalsBlocked()) {
             		emit changed(m_min, m_max, m_ticksCount, m_niceNumbers);
             	}
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.h +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$
             **
             ****************************************************************************/
             #ifndef ABSTRACTBARSERIES_H
             #define ABSTRACTBARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QAbstractBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QAbstractBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
             protected:
                 explicit QAbstractBarSeries(QObject *parent = 0);
             public:
                 virtual ~QAbstractBarSeries();
-                virtual QAbstractSeries::SeriesType type() const = 0;
+            //    virtual QAbstractSeries::SeriesType type() const = 0;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
                 QList<QBarSet*> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 bool isLabelsVisible() const;
             protected:
                 explicit QAbstractBarSeries(QAbstractBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void hovered(bool status, QBarSet *barset);
                 void countChanged();
                 void labelsVisibleChanged();
                 void barsetsAdded(QList<QBarSet*> sets);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
                 Q_DECLARE_PRIVATE(QAbstractBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTBARSERIES_H

src/qabstractseries.cpp +10 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 "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmlclass AbstractSeries
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for QXYSeries.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for QXYSeries.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if(d_ptr->m_dataset) qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString& name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Sets the visibility of series to \a visible
             */
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             /*!
                 Returns the visibility of series
             */
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart* QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             void QAbstractSeries::adjustView()
             {
                 //TODO:
             }
+            /*!
+                \brief Sets the visibility of the series to true
+                \sa setVisible(), isVisible()
+            */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
+            /*!
+                \brief Sets the visibility of the series to false
+                \sa setVisible(), isVisible()
+            */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q):
                 q_ptr(q),
                 m_chart(0),
                 m_dataset(0),
                 m_visible(true)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +22 -2

             /****************************************************************************
             **
             ** 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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QGraphicsLayout>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::margins
              Margins around the plot area. Note that the margin area is used for drawing chart title, legend and axes.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              Note: changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              \fn void QChart::marginsChanged(QRectF newMargins)
              The margins around plot area have changed to \a newMargins. This may happen for example if you change title font size,
              modify axes or hide/show legend.
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
                 //connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
                 setLayout(d_ptr->m_presenter->layout());
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 setLayout(0);
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of the object.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              \sa removeSeries(), removeAllSeries()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyIsNull(factor))
                     return;
                 if (qFuzzyCompare(factor, 1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->m_presenter->zoomIn(factor);
                 else
                     d_ptr->m_presenter->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart asociated with the specified \a series
+             If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis* QChart::axisX(QAbstractSeries* series) const
             {
                 return d_ptr->m_dataset->axisX(series);
             }
             /*!
              Returns the pointer to the y axis object of the chart asociated with the specified \a series
+             If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              NOTICE: This function has to be called after series has been added to the chart if no customized axes are set to the chart. Otherwise axisX(), axisY() calls return NULL.
              Creates the axes for the chart based on the series that has already been added to the chart.
-             If QXYSeries derived series has been added to the chart then QValuesAxes are created as X and Y axes for the series.
-             If QBarSeries or series types derived from it has been added then QBarCategoriesAxis is created as X axis and QValueAxis as Y axis.
+            \table
+                 \header
+                     \o Series type
+                     \o X-axis
+                     \o Y-axis
+                 \row
+                     \o QXYSeries
+                     \o QValuesAxis
+                     \o QValuesAxis
+                 \row
+                     \o QBarSeries
+                     \o QBarCategoriesAxis
+                     \o QValuesAxis
+                 \row
+                     \o QPieSeries
+                     \o None
+                     \o None
+                 \endtable
              If there are several QXYSeries derived series added to the chart and no other series type has been added then only one pair of axes is created.
              If there are sevaral series added of different types then each series gets its own axes pair.
              NOTICE: if there is more than one x and y axes created then no axis is drawn by default and one needs to choose explicitly which axis should be shown.
              Axis specifix to the series can be later obtained from the chart by providing the series as the parameter of axisX(), axisY() function calls.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), setAxisX(), setAxisY()
              */
             void QChart::createDefaultAxes()
             {
             	d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->m_presenter->scroll(dx, dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
               Returns all the series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries*> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             void QChart::setMarginsMinimum(const QRectF& margins)
             {
                 d_ptr->m_presenter->setMarginsMinimum(margins);
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
             */
             void QChart::setAxisX(QAbstractAxis* axis , QAbstractSeries *series)
             {
                 d_ptr->m_dataset->setAxisX(series,axis);
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisX(), createDefaultAxes()
             */
             void QChart::setAxisY( QAbstractAxis* axis , QAbstractSeries *series)
             {
                 d_ptr->m_dataset->setAxisY(series,axis);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QAbstractAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAbstractAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QAbstractAxis*)),m_presenter,SLOT(handleAxisRemoved(QAbstractAxis*)));
                 //QObject::connect(m_presenter, SIGNAL(marginsChanged(QRectF)), q_ptr, SIGNAL(marginsChanged(QRectF)));
             }
             #include "moc_qchart.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