HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2785:b99b50e22ed3

Fix documentation typo...

Miikka Heikkinen -

r2785:b99b50e22ed3

parent child

Context file:

r2785:b99b50e22ed3

Collapse all files

src/charts/qchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <private/legendscroller_p.h>
             #include <private/qlegend_p.h>
             #include <private/chartbackground_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/abstractchartlayout_p.h>
             #include <private/charttheme_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/chartdataset_p.h>
             #include <QtWidgets/QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QT_CHARTS_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
              \value ChartThemeQt
              */
             /*!
              \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
              \inmodule Qt Charts
              \brief Main chart API for Qt Charts.
              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::backgroundRoundness
-             The diameter of the rounding cirle at the corners of the chart background.
+             The diameter of the rounding circle at the corners of the chart background.
              */
             /*!
              \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 example} 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. Chart title supports html formatting.
              */
             /*!
              \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
              */
             /*!
               \property QChart::localizeNumbers
               \since QtCharts 2.0
               When \c{true}, all generated numbers appearing in various series and axis labels will be
               localized using the QLocale set with the locale property.
               When \c{false}, the "C" locale is always used.
               Defaults to \c{false}.
               \note This property doesn't affect QDateTimeAxis labels, which always use the QLocale set with
               the locale property.
               \sa locale
             */
             /*!
               \property QChart::locale
               \since QtCharts 2.0
               Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
               This also determines the locale used to format QDateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \property QChart::plotArea
               Holds the rectangle within which the drawing of the chart is done.
               It does not include the area defined by margins.
             */
             /*!
              \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);
             }
             /*!
              Resets the series domains to what they were before any zoom method was called.
              Note that this will also reset any scrolls and explicit axis range settings done between
              the first zoom operation and calling this method. If no zoom operation has been
              done, this method does nothing.
              */
             void QChart::zoomReset()
             {
                 d_ptr->zoomReset();
             }
             /*!
              Returns true if any series has a zoomed domain.
              */
             bool QChart::isZoomed()
             {
                return d_ptr->isZoomed();
             }
             /*!
              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
                      \li Series type
                      \li X-axis
                      \li Y-axis
                  \row
                      \li QXYSeries
                      \li QValueAxis
                      \li QValueAxis
                  \row
                      \li QBarSeries
                      \li QBarCategoryAxis
                      \li QValueAxis
                  \row
                      \li QPieSeries
                      \li None
                      \li 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::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;
             }
             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 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::setLocalizeNumbers(bool localize)
             {
                 d_ptr->m_presenter->setLocalizeNumbers(localize);
             }
             bool QChart::localizeNumbers() const
             {
                 return d_ptr->m_presenter->localizeNumbers();
             }
             void QChart::setLocale(const QLocale &locale)
             {
                 d_ptr->m_presenter->setLocale(locale);
             }
             QLocale QChart::locale() const
             {
                 return d_ptr->m_presenter->locale();
             }
             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();
             }
             void QChart::setBackgroundRoundness(qreal diameter)
             {
                 d_ptr->m_presenter->setBackgroundRoundness(diameter);
             }
             qreal QChart::backgroundRoundness() const
             {
                 return d_ptr->m_presenter->backgroundRoundness();
             }
             /*!
               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_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q)),
                 m_type(type)
             {
                 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*)));
                 QObject::connect(m_presenter, &ChartPresenter::plotAreaChanged, q, &QChart::plotAreaChanged);
             }
             QChartPrivate::~QChartPrivate()
             {
                 delete m_themeManager;
             }
             // Hackish solution to the problem of explicitly assigning the default pen/brush/font
             // to a series or axis and having theme override it:
             // Initialize pens, brushes, and fonts to something nobody is likely to ever use,
             // so that default theme initialization will always set these properly.
             QPen &QChartPrivate::defaultPen()
             {
                 static QPen defaultPen(QColor(1, 2, 0), 0.93247536);
                 return defaultPen;
             }
             QBrush &QChartPrivate::defaultBrush()
             {
                 static QBrush defaultBrush(QColor(1, 2, 0), Qt::Dense7Pattern);
                 return defaultBrush;
             }
             QFont &QChartPrivate::defaultFont()
             {
                 static bool defaultFontInitialized(false);
                 static QFont defaultFont;
                 if (!defaultFontInitialized) {
                     defaultFont.setPointSizeF(8.34563465);
                     defaultFontInitialized = true;
                 }
                 return defaultFont;
             }
             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::zoomReset()
             {
                 m_dataset->zoomResetDomain();
             }
             bool QChartPrivate::isZoomed()
             {
                 return m_dataset->isZoomedDomain();
             }
             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"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QtGui/QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include "declarativemargins.h"
             #include <private/chartdataset_p.h>
             #include "declarativeaxes.h"
             #include <private/qchart_p.h>
             #include <QtCharts/QPolarChart>
             #ifndef QT_ON_ARM
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtWidgets/QGraphicsSceneHoverEvent>
             #include <QtWidgets/QApplication>
             #include <QtCore/QTimer>
             #include <QtCore/QThread>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCharts
                 \brief Chart element.
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animationOptions
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart.
               See the Qt documentation for more details of Font.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty color ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty real ChartView::backgroundRoundness
-              The diameter of the rounding cirle at the corners of the chart background.
+              The diameter of the rounding circle at the corners of the chart background.
             */
             /*!
               \qmlproperty color ChartView::plotAreaColor
               The color of the background of the chart's plot area. By default plot area background uses chart's
               background color.
               \sa ChartView::backgroundColor
             */
             /*!
               \qmlproperty list<AbstractAxis> ChartView::axes
               The axes of the ChartView.
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::margins
             */
             /*!
               \qmlproperty Margins ChartView::margins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend.
             */
             /*!
               \qmlproperty bool ChartView::localizeNumbers
               \since QtCharts 2.0
               When \c{true}, all generated numbers appearing in various series and axis labels will be
               localized using the default QLocale of the application, which defaults to the system locale.
               When \c{false}, the "C" locale is always used.
               Defaults to \c{false}.
               \sa locale
             */
             /*!
               \qmlproperty locale ChartView::locale
               \since QtCharts 2.0
               Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
               This also determines the locale used to format DateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisX(AbstractAxis axis, AbstractSeries series)
               Set the x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisY(AbstractAxis axis, AbstractSeries series)
               Set the y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoom(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QQuickItem *parent)
                 : QQuickPaintedItem(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
                 : QQuickPaintedItem(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
                 m_currentSceneImage = 0;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
                 connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>)));
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 connect(m_chart, &QChart::plotAreaChanged, this, &DeclarativeChart::plotAreaChanged);
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit marginsChanged();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = 0;
                 m_sceneImageLock.unlock();
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Connect to axis changed signals (unless this is a pie series)
                         if (!qobject_cast<DeclarativePieSeries *>(series)) {
                             connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QQuickItem::componentComplete();
             }
             void DeclarativeChart::seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                                           Qt::Orientations orientation,
                                                           Qt::Alignment alignment)
             {
                 if (!series->attachedAxes().contains(axis)) {
                     // Remove & delete old axes that are not attached to any other series
                     foreach (QAbstractAxis* oldAxis, m_chart->axes(orientation, series)) {
                         bool otherAttachments = false;
                         if (oldAxis != axis) {
                             foreach (QAbstractSeries *oldSeries, m_chart->series()) {
                                 if (oldSeries != series && oldSeries->attachedAxes().contains(oldAxis)) {
                                     otherAttachments = true;
                                     break;
                                 }
                             }
                             if (!otherAttachments) {
                                 m_chart->removeAxis(oldAxis);
                                 delete oldAxis;
                             }
                         }
                     }
                     if (!m_chart->axes(orientation).contains(axis))
                         m_chart->addAxis(axis, alignment);
                     series->attachAxis(axis);
                 }
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignBottom);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignTop);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignLeft);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignRight);
                 } else {
                     qWarning() << "Trying to set axisYRight to null.";
                 }
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QQuickItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::sceneChanged(QList<QRectF> region)
             {
                 Q_UNUSED(region);
                 if (m_guiThreadId == m_paintThreadId) {
                     // Rendering in gui thread, no need for shenannigans, just update
                     update();
                 } else {
                     // Multi-threaded rendering, need to ensure scene is actually rendered in gui thread
                     if (!m_updatePending) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
                         QTimer::singleShot(0, this, SLOT(renderScene()));
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32);
                 m_currentSceneImage->fill(Qt::transparent);
                 QPainter painter(m_currentSceneImage);
                 if (antialiasing())
                     painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
                 QRect renderRect(QPoint(0, 0), m_chart->size().toSize());
                 m_scene->render(&painter, renderRect, renderRect);
                 m_sceneImageLock.unlock();
                 update();
             }
             void DeclarativeChart::paint(QPainter *painter)
             {
                 if (!m_paintThreadId) {
                     m_paintThreadId = QThread::currentThreadId();
                     if (m_guiThreadId == m_paintThreadId) {
                         // No need for scene image in single threaded rendering, so delete
                         // the one that got made by default before the rendering type was
                         // detected.
                         delete m_currentSceneImage;
                         m_currentSceneImage = 0;
                     }
                 }
                 if (m_guiThreadId == m_paintThreadId) {
                     QRectF renderRect(QPointF(0, 0), m_chart->size());
                     m_scene->render(painter, renderRect, renderRect);
                 } else {
                     m_sceneImageLock.lock();
                     if (m_currentSceneImage) {
                         QRect imageRect(QPoint(0, 0), m_currentSceneImage->size());
                         QRect itemRect(QPoint(0, 0), QSize(width(), height()));
                         painter->drawImage(itemRect, *m_currentSceneImage, imageRect);
                     }
                     m_sceneImageLock.unlock();
                 }
             }
             void DeclarativeChart::mousePressEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 mouseEvent.setScreenPos(event->globalPos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(event->buttons());
                 mouseEvent.setButton(event->button());
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
                 m_mousePressButtons = event->buttons();
                 m_mousePressButton = Qt::NoButton;
             }
             void DeclarativeChart::hoverMoveEvent(QHoverEvent *event)
             {
                 // Convert hover move to mouse move, since we don't seem to get actual mouse move events.
                 // QGraphicsScene generates hover events from mouse move events, so we don't need
                 // to pass hover events there.
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 // Hover events do not have global pos in them, and the screen position doesn't seem to
                 // matter anyway in this use case, so just pass event pos instead of trying to
                 // calculate the real screen position.
                 mouseEvent.setScreenPos(event->pos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 m_lastMouseMoveScenePoint = mouseEvent.scenePos();
                 m_lastMouseMoveScreenPoint = mouseEvent.screenPos();
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseDoubleClickEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCharts::DeclarativeChart::setPlotAreaColor(QColor color)
             {
                 QBrush b = m_chart->plotAreaBackgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setPlotAreaBackgroundBrush(b);
                     m_chart->setPlotAreaBackgroundVisible(true);
                     emit plotAreaColorChanged();
                 }
             }
             QColor QtCharts::DeclarativeChart::plotAreaColor()
             {
                 return m_chart->plotAreaBackgroundBrush().color();
             }
             void DeclarativeChart::setLocalizeNumbers(bool localize)
             {
                 if (m_chart->localizeNumbers() != localize) {
                     m_chart->setLocalizeNumbers(localize);
                     emit localizeNumbersChanged();
                 }
             }
             bool DeclarativeChart::localizeNumbers() const
             {
                 return m_chart->localizeNumbers();
             }
             void QtCharts::DeclarativeChart::setLocale(const QLocale &locale)
             {
                 if (m_chart->locale() != locale) {
                     m_chart->setLocale(locale);
                     emit localeChanged();
                 }
             }
             QLocale QtCharts::DeclarativeChart::locale() const
             {
                 return m_chart->locale();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::backgroundRoundness() const
             {
                 return m_chart->backgroundRoundness();
             }
             void DeclarativeChart::setBackgroundRoundness(qreal diameter)
             {
                 if (m_chart->backgroundRoundness() != diameter) {
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QQmlListProperty<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QQmlListProperty<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             }
             void DeclarativeChart::axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count();
                 }
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]);
                     return axes.at(index);
                 }
                 return 0;
             }
             void DeclarativeChart::axesClearFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 // Empty implementation
                 Q_UNUSED(list);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach (QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea: {
                     DeclarativeAreaSeries *area = new DeclarativeAreaSeries();
                     DeclarativeLineSeries *line = new DeclarativeLineSeries();
                     line->setParent(area);
                     area->setUpperSeries(line);
                     series = area;
                     break;
                 }
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBoxPlot:
                     series = new DeclarativeBoxPlotSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 if (series) {
                     // Connect to axis changed signals (unless this is a pie series)
                     if (!qobject_cast<DeclarativePieSeries *>(series)) {
                         connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                     }
                     series->setName(name);
                     m_chart->addSeries(series);
                     if (!axisX || !axisY)
                         initializeAxes(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Horizontal, Qt::AlignBottom);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Vertical, Qt::AlignLeft);
             }
             QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series)
             {
                 if (!series) {
                     qWarning() << "No axis type defined for null series";
                     return 0;
                 }
                 foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) {
                     if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation))
                         return existingAxis;
                 }
                 switch (series->d_ptr->defaultAxisType(orientation)) {
                 case QAbstractAxis::AxisTypeValue:
                     return new QValueAxis(this);
                 case QAbstractAxis::AxisTypeBarCategory:
                     return new QBarCategoryAxis(this);
                 case QAbstractAxis::AxisTypeCategory:
                     return new QCategoryAxis(this);
             #ifndef QT_ON_ARM
                 case QAbstractAxis::AxisTypeDateTime:
                     return new QDateTimeAxis(this);
             #endif
                 case QAbstractAxis::AxisTypeLogValue:
                     return new QLogValueAxis(this);
                 default:
                     // assume AxisTypeNoAxis
                     return 0;
                 }
             }
             void DeclarativeChart::initializeAxes(QAbstractSeries *series)
             {
                 if (qobject_cast<DeclarativeLineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeLineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeScatterSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeScatterSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeSplineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeSplineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeAreaSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeAreaSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativePercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativePercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBoxPlotSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBoxPlotSeries *>(series)->m_axes);
                 // else: do nothing
             }
             void DeclarativeChart::doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes)
             {
                 // Initialize axis X
                 if (axes->axisX())
                     axes->emitAxisXChanged();
                 else if (axes->axisXTop())
                     axes->emitAxisXTopChanged();
                 else
                     axes->setAxisX(defaultAxis(Qt::Horizontal, series));
                 // Initialize axis Y
                 if (axes->axisY())
                     axes->emitAxisYChanged();
                 else if (axes->axisYRight())
                     axes->emitAxisYRightChanged();
                 else
                     axes->setAxisY(defaultAxis(Qt::Vertical, series));
             }
             #include "moc_declarativechart.cpp"
             QT_CHARTS_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