HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2503:1faea7ae9e36

Fix warnings in documentation build...

Miikka Heikkinen -

r2503:1faea7ae9e36

parent child

Context file:

r2503:1faea7ae9e36

Collapse all files

src/qchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "abstractchartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             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
              */
             /*!
              \enum QChart::ChartType
              This enum describes the chart type.
              \value ChartTypeUndefined
              \value ChartTypeCartesian
              \value ChartTypePolar
              */
             /*!
              \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 legend and
              axes. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView, QPolarChart
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Specifies whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible
              */
             /*!
              \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::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              This property is deprecated; use margins property instead.
              \sa margins
              */
             /*!
              \property QChart::margins
              Margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \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.
              */
             /*!
              \property QChart::chartType
              Chart type indicates if the chart is a cartesian chart or a polar chart.
              This property is set internally and it is read only.
              \sa QPolarChart
              */
             /*!
              \property QChart::plotAreaBackgroundVisible
              Specifies whether the chart plot area background is visible or not.
              \note By default the plot area background is not visible and the plot area uses
              the general chart background.
              \sa setPlotAreaBackgroundBrush(), setPlotAreaBackgroundPen(), backgroundVisible
              */
             /*!
              \internal
              Constructs a chart object of \a type which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              This constructor is called only by subclasses.
             */
             QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, type))
             {
                 d_ptr->init();
             }
             /*!
              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(this, ChartTypeCartesian))
             {
                 d_ptr->init();
             }
             /*!
              Destroys the chart object and its children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of it.
              \note A newly added series is attached to no axes by default, including any axes that were created for the chart
              using createDefaultAxes() before the series was added to the chart. If no axes are attached to
              the newly added series before the chart is shown, the series will get drawn as if it had axes with ranges
              that exactly fit the series to the plot area of the chart. This can be confusing if the same chart also displays other
              series that have properly attached axes, so always make sure you either call createDefaultAxes() after
              a series has been added or explicitly attach axes for the series.
              \sa removeSeries(), removeAllSeries(), createDefaultAxes(), QAbstractSeries::attachAxis()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series from the chart.
              The chart releases its ownership of the specified \a series object.
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes and deletes all series objects that have been added to the chart.
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                     removeSeries(s);
                     delete s;
                 }
             }
             /*!
              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();
             }
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart title.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
              Gets the font that is used for drawing the chart title.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for drawing the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for drawing the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
              Zooms in the view by a factor of two.
              */
             void QChart::zoomIn()
             {
                 d_ptr->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              \note This is not supported for polar charts.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 if (d_ptr->m_type == QChart::ChartTypePolar)
                     return;
                 d_ptr->zoomIn(rect);
             }
             /*!
              Zooms out the view by a factor of two.
              */
             void QChart::zoomOut()
             {
                 d_ptr->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a custom \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 (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
              Returns a pointer to the horizontal axis attached to the specified \a series.
              If no \a series is specified, the first horizontal axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns a pointer to the vertical axis attached to the specified \a series.
              If no \a series is specified, the first vertical axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns the axes attached to the \a series with \a orientation. If no \a series is provided,
              then all axes added to the chart with the specified orientation are returned.
              \sa addAxis(), createDefaultAxes()
              */
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 if (series) {
                     foreach (QAbstractAxis *axis, series->attachedAxes()){
                         if (orientation.testFlag(axis->orientation()))
                             result << axis;
                     }
                 } else {
                     foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                         if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                             result << axis;
                     }
                 }
                 return result;
             }
             /*!
              Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to
              the chart will be deleted.
              \note This function has to be called after all series have been added to the chart. The axes created by this function
              will NOT get automatically attached to any series added to the chart after this function has been called.
              A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing
              if there are other series with properly attached axes also present.
              \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
              \endtable
              If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created.
              If there are several series of different types added to the chart, then each series gets its own axes pair.
              The axes specific to the series can be later obtained from the chart by providing the series as the parameter for axes() function call.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), axes(), setAxisX(), setAxisY(), QAbstractSeries::attachAxis()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays with the chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             QChart::ChartType QChart::chartType() const
             {
                 return d_ptr->m_type;
             }
             /*!
                 Returns the the rectangle within which the drawing of the chart is done.
                 It does not include the area defined by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
             /*!
                 Sets the \a brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundPen(), plotAreaBackgroundBrush()
              */
             void QChart::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundBrush(brush);
             }
             /*!
                 Returns the brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundPen(), setPlotAreaBackgroundBrush()
              */
             QBrush QChart::plotAreaBackgroundBrush() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundBrush();
             }
             /*!
                 Sets the \a pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundBrush(), plotAreaBackgroundPen()
              */
             void QChart::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundPen(pen);
             }
             /*!
-                Returns the \a pen for the background of the plot area of the chart.
+                Returns the pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundBrush(), setPlotAreaBackgroundPen()
              */
             QPen QChart::plotAreaBackgroundPen() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundPen();
             }
             void QChart::setPlotAreaBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundVisible(visible);
             }
             bool QChart::isPlotAreaBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isPlotAreaBackgroundVisible();
             }
             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.
                 For polar charts, \a dx indicates the angle along angular axis instead of distance.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->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 series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a bottom-aligned horizontal axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any horizontal axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisY(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisX(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Horizontal, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignBottom);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a left-aligned vertical axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any vertical axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisX(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisY(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
               \sa removeAxis(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::addAxis(QAbstractAxis *axis, Qt::Alignment alignment)
             {
                 d_ptr->m_dataset->addAxis(axis, alignment);
             }
             /*!
               Removes the \a axis from the chart.
               The chart releases its ownership of the specified \a axis object.
               \sa addAxis(), createDefaultAxes(), QAbstractSeries::detachAxis()
             */
             void QChart::removeAxis(QAbstractAxis *axis)
             {
                 d_ptr->m_dataset->removeAxis(axis);
             }
             /*!
               Returns the value in the \a series domain that corresponds to the \a position relative to chart widget.
             */
             QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToValue(position, series);
             }
             /*!
               Returns the position on the chart widget that corresponds to the \a value in the \a series domain.
             */
             QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToPosition(value, series);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q, QChart::ChartType type):
                 q_ptr(q),
                 m_type(type),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q))
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::init()
             {
                 m_legend = new LegendScroller(q_ptr);
                 q_ptr->setTheme(QChart::ChartThemeLight);
                 q_ptr->setLayout(m_presenter->layout());
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +11 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
             #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \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()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with other points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point (\a oldX, \a oldY) with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
                 replace(index, newPoint);
             }
+            /*!
+              Replaces the point at \a index with data point (\a newX, \a newY).
+              \sa QXYSeries::pointReplaced()
+            */
             void QXYSeries::replace(int index, qreal newX, qreal newY)
             {
                 replace(index, QPointF(newX, newY));
             }
+            /*!
+              Replaces the point at \a index with \a newPoint.
+              \sa QXYSeries::pointReplaced()
+            */
             void QXYSeries::replace(int index, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points.
               \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 remove(index);
             }
+            /*!
+              Removes the point at \a index from the series.
+            */
             void QXYSeries::remove(int index)
             {
                 Q_D(QXYSeries);
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 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) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             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;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             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;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new XYAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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