HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2498:e824058bc192

Add API to specify plot area background....

Miikka Heikkinen -

r2498:e824058bc192

parent child

Context file:

r2498:e824058bc192

Collapse all files

plugins/declarative/declarativechart.cpp +24 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 "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis.h"
             #include "qlogvalueaxis.h"
             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "declarativemargins.h"
             #include "chartdataset_p.h"
             #include "declarativeaxes.h"
             #include "qchart_p.h"
             #include "qpolarchart.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #ifdef CHARTS_FOR_QUICK2
             #include <QGraphicsSceneMouseEvent>
             #include <QGraphicsSceneHoverEvent>
             #include <QApplication>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 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 ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/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 \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \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 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 bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
             */
             /*!
               \qmlproperty real ChartView::leftMargin
             */
             /*!
               \qmlproperty real ChartView::rightMargin
             */
             /*!
               \qmlproperty Margins ChartView::minimumMargins
               Deprecated; use margins instead.
               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. Please note that setting the
               properties of minimumMargins may be bigger than the defined value, depending on other ChartView
               properties that affect it's layout. If you need to know the actual plotting area used at any
               given time, you can check ChartView::plotArea instead.
             */
             /*!
               \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::minimumMargins
             */
             /*!
               \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.
             */
             /*!
               \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 Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoomY(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::onPlotAreaChanged(rect plotArea)
               The plot area of the chart has changed. This may happen for example, if you modify minimumMargins
               or if you resize the chart, or if you modify font size related properties of the legend or chart
               title.
             */
             /*!
               \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(QDECLARATIVE_ITEM *parent)
                 : QDECLARATIVE_PAINTED_ITEM(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QDECLARATIVE_ITEM *parent)
                 : QDECLARATIVE_PAINTED_ITEM(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
             #ifdef CHARTS_FOR_QUICK2
                 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(update()));
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
             #else
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart(this);
                 else
                     m_chart = new QChart(this);
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             #endif
                 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(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(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*)));
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit minimumMarginsChanged();
                 emit plotAreaChanged(m_chart->plotArea());
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             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(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QDECLARATIVE_ITEM::componentComplete();
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Horizontal).contains(axis))
                         m_chart->addAxis(axis, Qt::AlignBottom);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Horizontal).contains(axis))
                         m_chart->addAxis(axis, Qt::AlignTop);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Vertical).contains(axis))
                         m_chart->addAxis(axis, Qt::AlignLeft);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     if (!m_chart->axes(Qt::Vertical).contains(axis))
                         m_chart->addAxis(axis, Qt::AlignRight);
                     if (!s->attachedAxes().contains(axis))
                         s->attachAxis(axis);
                 } 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());
                     }
                 }
                 QDECLARATIVE_ITEM::geometryChanged(newGeometry, oldGeometry);
                 // It would be better to trigger the plotAreaChanged signal from QChart::plotAreaChanged or
                 // similar. Since that kind of a signal is not clearly needed in the C++ API the work-around is
                 // to implement it here for the QML API purposes.
                 emit plotAreaChanged(m_chart->plotArea());
             }
             #ifdef CHARTS_FOR_QUICK2
             void DeclarativeChart::paint(QPainter *painter)
             {
                 QRectF renderRect(QPointF(0, 0), m_chart->size());
                 m_scene->render(painter, renderRect, renderRect);
             }
             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::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             #endif
             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 QtCommercialChart::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 QtCommercialChart::DeclarativeChart::plotAreaColor()
+            {
+                return m_chart->plotAreaBackgroundBrush().color();
+            }
             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::topMargin()
             {
                 qWarning() << "ChartView.topMargin is deprecated. Use margins instead.";
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 qWarning() << "ChartView.bottomMargin is deprecated. Use margins instead.";
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 qWarning() << "ChartView.leftMargin is deprecated. Use margins instead.";
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 qWarning() << "ChartView.rightMargin is deprecated. Use margins instead.";
                 return m_chart->margins().right();
             }
             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);
             }
             QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QDECLARATIVE_LIST_PROPERTY<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
             #ifdef CHARTS_FOR_QUICK2
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             #else
                             &DeclarativeChart::axesAtFunc);
             #endif
             }
             void DeclarativeChart::axesAppendFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QDECLARATIVE_LIST_PROPERTY<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(QDECLARATIVE_LIST_PROPERTY<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(QDECLARATIVE_LIST_PROPERTY<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();
                     area->setUpperSeries(new DeclarativeLineSeries());
                     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::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)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                     if (series->attachedAxes().count() < 2)
                         initializeAxes(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)
                     m_chart->setAxisX(axis, series);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis)
                     m_chart->setAxisY(axis, series);
             }
             void DeclarativeChart::createDefaultAxes()
             {
                 qWarning() << "ChartView.createDefaultAxes() is deprecated. Axes are created automatically.";
             }
             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: 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"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativechart.h +4 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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
             #include <QtCore/QtGlobal>
             #include "shared_defines.h"
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQuick/QQuickItem>
             #include <QtQuick/QQuickPaintedItem>
             #include <QtWidgets/QGraphicsScene>
             #else
             #include <QtDeclarative/QDeclarativeItem>
             #endif
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeMargins;
             class Domain;
             class DeclarativeAxes;
             class DeclarativeChart : public QDECLARATIVE_PAINTED_ITEM
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QLegend *legend READ legend)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)
                 Q_PROPERTY(bool dropShadowEnabled READ dropShadowEnabled WRITE setDropShadowEnabled NOTIFY dropShadowEnabledChanged)
                 Q_PROPERTY(qreal topMargin READ topMargin)
                 Q_PROPERTY(qreal bottomMargin READ bottomMargin)
                 Q_PROPERTY(qreal leftMargin READ leftMargin)
                 Q_PROPERTY(qreal rightMargin READ rightMargin)
                 Q_PROPERTY(DeclarativeMargins *minimumMargins READ minimumMargins NOTIFY minimumMarginsChanged REVISION 1)
                 Q_PROPERTY(DeclarativeMargins *margins READ margins NOTIFY marginsChanged REVISION 2)
                 Q_PROPERTY(QRectF plotArea READ plotArea NOTIFY plotAreaChanged REVISION 1)
+                Q_PROPERTY(QColor plotAreaColor READ plotAreaColor WRITE setPlotAreaColor NOTIFY plotAreaColorChanged REVISION 3)
             #ifdef CHARTS_FOR_QUICK2
                 Q_PROPERTY(QQmlListProperty<QAbstractAxis> axes READ axes REVISION 2)
             #else
                 Q_PROPERTY(QDeclarativeListProperty<QAbstractAxis> axes READ axes REVISION 2)
             #endif
                 Q_ENUMS(Animation)
                 Q_ENUMS(Theme)
                 Q_ENUMS(SeriesType)
             public:
                 // duplicating enums from QChart to make the QML api namings 1-to-1 with the C++ api
                 enum Theme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum Animation {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             public:
                 DeclarativeChart(QDECLARATIVE_ITEM *parent = 0);
                 ~DeclarativeChart();
             public: // From parent classes
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
             #ifdef CHARTS_FOR_QUICK2
                 void paint(QPainter *painter);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void hoverMoveEvent(QHoverEvent *event);
             private Q_SLOTS:
                 void handleAntialiasingChanged(bool enable);
             #endif
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 QFont titleFont() const;
                 void setTitleFont(const QFont &font);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
+                Q_REVISION(3) void setPlotAreaColor(QColor color);
+                Q_REVISION(3) QColor plotAreaColor();
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 // Margins & plotArea
                 qreal topMargin();
                 qreal bottomMargin();
                 qreal leftMargin();
                 qreal rightMargin();
                 DeclarativeMargins *minimumMargins() { return m_margins; }
                 Q_REVISION(2) DeclarativeMargins *margins() { return m_margins; }
                 QRectF plotArea() { return m_chart->plotArea(); }
                 // Axis handling
                 QAbstractAxis *defaultAxis(Qt::Orientation orientation, QAbstractSeries *series);
                 void initializeAxes(QAbstractSeries *series);
                 void doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes);
                 QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> axes();
                 static void axesAppendFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, QAbstractAxis *element);
                 static int axesCountFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list);
                 static QAbstractAxis *axesAtFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, int index);
                 static void axesClearFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list);
             public:
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(int type, QString name = "", QAbstractAxis *axisX = 0, QAbstractAxis *axisY = 0);
                 Q_INVOKABLE void removeSeries(QAbstractSeries *series);
                 Q_INVOKABLE void removeAllSeries() { m_chart->removeAllSeries(); }
                 Q_INVOKABLE void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void createDefaultAxes();
                 Q_INVOKABLE QAbstractAxis *axisX(QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisY(QAbstractSeries *series = 0);
                 Q_INVOKABLE void zoom(qreal factor);
                 Q_INVOKABLE void scrollLeft(qreal pixels);
                 Q_INVOKABLE void scrollRight(qreal pixels);
                 Q_INVOKABLE void scrollUp(qreal pixels);
                 Q_INVOKABLE void scrollDown(qreal pixels);
             Q_SIGNALS:
                 void axisLabelsChanged();
                 void titleColorChanged(QColor color);
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
                 void minimumMarginsChanged();
                 Q_REVISION(2) void marginsChanged();
                 void plotAreaChanged(QRectF plotArea);
                 void seriesAdded(QAbstractSeries *series);
                 void seriesRemoved(QAbstractSeries *series);
+                Q_REVISION(3) void plotAreaColorChanged();
             private Q_SLOTS:
                 void changeMinimumMargins(int top, int bottom, int left, int right);
                 void handleAxisXSet(QAbstractAxis *axis);
                 void handleAxisYSet(QAbstractAxis *axis);
                 void handleAxisXTopSet(QAbstractAxis *axis);
                 void handleAxisYRightSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series);
             protected:
                 explicit DeclarativeChart(QChart::ChartType type, QDECLARATIVE_ITEM *parent);
             private:
                 void initChart(QChart::ChartType type);
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
             #ifdef CHARTS_FOR_QUICK2
                 QGraphicsScene *m_scene;
                 QPointF m_mousePressScenePoint;
                 QPoint m_mousePressScreenPoint;
                 QPointF m_lastMouseMoveScenePoint;
                 QPoint m_lastMouseMoveScreenPoint;
                 Qt::MouseButton m_mousePressButton;
                 Qt::MouseButtons m_mousePressButtons;
             #endif
                 DeclarativeMargins *m_margins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVECHART_H

plugins/declarative/plugin.cpp +1 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 "qchart.h"
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "qlogvalueaxis.h"
             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
             #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativeaxes.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include "declarativemargins.h"
             #include "qarealegendmarker.h"
             #include "qbarlegendmarker.h"
             #include "qpielegendmarker.h"
             #include "qxylegendmarker.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #include "shared_defines.h"
             #include <QAbstractItemModel>
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlExtensionPlugin>
             #else
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #endif
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QList<QPieSlice *>)
             Q_DECLARE_METATYPE(QList<QBarSet *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
             // NOTE: Hackish fixes for Qt5 (beta2).
             // These should not be needed or at least they are not needed in Qt4.
             Q_DECLARE_METATYPE(DeclarativeChart *)
             Q_DECLARE_METATYPE(DeclarativePolarChart *)
             Q_DECLARE_METATYPE(DeclarativeMargins *)
             Q_DECLARE_METATYPE(DeclarativeAreaSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSet *)
             Q_DECLARE_METATYPE(DeclarativeLineSeries *)
             Q_DECLARE_METATYPE(DeclarativePieSeries *)
             Q_DECLARE_METATYPE(DeclarativeScatterSeries *)
             Q_DECLARE_METATYPE(DeclarativeSplineSeries *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QCategoryAxis *)
             Q_DECLARE_METATYPE(QDateTimeAxis *)
             Q_DECLARE_METATYPE(QLogValueAxis *)
             Q_DECLARE_METATYPE(QLegend *)
             Q_DECLARE_METATYPE(QLegendMarker *)
             Q_DECLARE_METATYPE(QAreaLegendMarker *)
             Q_DECLARE_METATYPE(QBarLegendMarker *)
             Q_DECLARE_METATYPE(QPieLegendMarker *)
             Q_DECLARE_METATYPE(QHPieModelMapper *)
             Q_DECLARE_METATYPE(QHXYModelMapper *)
             Q_DECLARE_METATYPE(QPieModelMapper *)
             Q_DECLARE_METATYPE(QHBarModelMapper *)
             Q_DECLARE_METATYPE(QBarModelMapper *)
             Q_DECLARE_METATYPE(QVBarModelMapper *)
             Q_DECLARE_METATYPE(QVPieModelMapper *)
             Q_DECLARE_METATYPE(QVXYModelMapper *)
             Q_DECLARE_METATYPE(QXYLegendMarker *)
             Q_DECLARE_METATYPE(QXYModelMapper *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QXYSeries *)
             Q_DECLARE_METATYPE(QAbstractBarSeries *)
             Q_DECLARE_METATYPE(QBarSeries *)
             Q_DECLARE_METATYPE(QBarSet *)
             Q_DECLARE_METATYPE(QAreaSeries *)
             Q_DECLARE_METATYPE(QHorizontalBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalPercentBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalStackedBarSeries *)
             Q_DECLARE_METATYPE(QLineSeries *)
             Q_DECLARE_METATYPE(QPercentBarSeries *)
             Q_DECLARE_METATYPE(QPieSeries *)
             Q_DECLARE_METATYPE(QPieSlice *)
             Q_DECLARE_METATYPE(QScatterSeries *)
             Q_DECLARE_METATYPE(QSplineSeries *)
             Q_DECLARE_METATYPE(QStackedBarSeries *)
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDECLARATIVE_EXTENSION_PLUGIN
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
             #else
             # if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDeclarativeExtensionInterface")
             # endif
             #endif
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     qRegisterMetaType<QList<QAbstractAxis *> >();
                     // QtCommercial.Chart 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 1, 0, "DeclarativeAxes",
                                                            QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCommercial.Chart 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 2>(uri, 1, 2, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 2>(uri, 1, 2, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 2>(uri, 1, 2, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 2>(uri, 1, 2, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 1, 2, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 1, 2, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 1, 2, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
                     // QtCommercial.Chart 1.3
+                    qmlRegisterType<DeclarativeChart, 3>(uri, 1, 3, "ChartView");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
                     qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                     qmlRegisterType<QLogValueAxis>(uri, 1, 3, "LogValueAxis");
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

src/chartpresenter.cpp +63 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "chartitem_p.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxiselement_p.h"
             #include "chartbackground_p.h"
             #include "cartesianchartlayout_p.h"
             #include "polarchartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
                   m_background(0),
+                  m_plotAreaBackground(0),
                   m_title(0)
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     m_options = options;
                     foreach(QAbstractSeries* series, m_series){
                         series->d_ptr->initializeAnimations(m_options);
                     }
                     foreach(QAbstractAxis* axis, m_axes){
                         axis->d_ptr->initializeAnimations(m_options);
                     }
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen);
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
+            void ChartPresenter::createPlotAreaBackgroundItem()
+            {
+                if (!m_plotAreaBackground) {
+                    if (m_chart->chartType() == QChart::ChartTypeCartesian)
+                        m_plotAreaBackground = new QGraphicsRectItem(rootItem());
+                    else
+                        m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
+                    // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
+                    // antialising artifacts with axis lines for some reason.
+                    m_plotAreaBackground->setPen(QPen(Qt::transparent));
+                    m_plotAreaBackground->setBrush(Qt::NoBrush);
+                    m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
+                    m_plotAreaBackground->setVisible(false);
+                }
+            }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                 m_animations.removeAll(qobject_cast<ChartAnimation *>(sender()));
                 if (m_animations.empty())
                     emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()), this, SLOT(handleAnimationFinished()), Qt::UniqueConnection);
                 if (!m_animations.isEmpty())
                     m_animations.append(animation);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
+            void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
+            {
+                createPlotAreaBackgroundItem();
+                m_plotAreaBackground->setBrush(brush);
+                m_layout->invalidate();
+            }
+            QBrush ChartPresenter::plotAreaBackgroundBrush() const
+            {
+                if (!m_plotAreaBackground)
+                    return QBrush();
+                return m_plotAreaBackground->brush();
+            }
+            void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
+            {
+                createPlotAreaBackgroundItem();
+                m_plotAreaBackground->setPen(pen);
+                m_layout->invalidate();
+            }
+            QPen ChartPresenter::plotAreaBackgroundPen() const
+            {
+                if (!m_plotAreaBackground)
+                    return QPen();
+                return m_plotAreaBackground->pen();
+            }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return m_title->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
+            void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
+            {
+                createPlotAreaBackgroundItem();
+                m_plotAreaBackground->setVisible(visible);
+            }
+            bool ChartPresenter::isPlotAreaBackgroundVisible() const
+            {
+                if (!m_plotAreaBackground)
+                    return false;
+                return m_plotAreaBackground->isVisible();
+            }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
+            QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
+            {
+                return m_plotAreaBackground;
+            }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +15 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //because of QChart::ChartThemeId
             #include <QRectF>
             #include <QMargins>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
-                    ShadesZValue ,
+                    PlotAreaZValue,
+                    ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
+                QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
+                void setPlotAreaBackgroundBrush(const QBrush &brush);
+                QBrush plotAreaBackgroundBrush() const;
+                void setPlotAreaBackgroundPen(const QPen &pen);
+                QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
+                void setPlotAreaBackgroundVisible(bool visible);
+                bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void startAnimation(ChartAnimation *animation);
                 //TODO refactor
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
+                QChart *chart() { return m_chart; }
             private:
                 void createBackgroundItem();
+                void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void animationsFinished();
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation *> m_animations;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
+                QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/chartthememanager.cpp +8 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 "qabstractseries_p.h"
             #include "qabstractaxis_p.h"
             #include <QTime>
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartThemeManager::ChartThemeManager(QChart* chart) :
                 m_chart(chart)
             {
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
             }
             void ChartThemeManager::setTheme(QChart::ChartTheme theme)
             {
                 if(m_theme.isNull() || theme != m_theme->id())
                 {
                     switch (theme) {
                         case QChart::ChartThemeLight:
                         m_theme.reset(new ChartThemeLight());
                         break;
                         case QChart::ChartThemeBlueCerulean:
                         m_theme.reset(new ChartThemeBlueCerulean());
                         break;
                         case QChart::ChartThemeDark:
                         m_theme.reset(new ChartThemeDark());
                         break;
                         case QChart::ChartThemeBrownSand:
                         m_theme.reset(new ChartThemeBrownSand());
                         break;
                         case QChart::ChartThemeBlueNcs:
                         m_theme.reset(new ChartThemeBlueNcs());
                         break;
                         case QChart::ChartThemeHighContrast:
                         m_theme.reset(new ChartThemeHighContrast());
                         break;
                         case QChart::ChartThemeBlueIcy:
                         m_theme.reset(new ChartThemeBlueIcy());
                         break;
                         default:
                         m_theme.reset(new ChartThemeSystem());
                         break;
                     }
                     if(!m_theme.isNull())
                     {
                         decorateChart(m_chart,m_theme.data(),true);
                         decorateLegend(m_chart->legend(),m_theme.data(),true);
                         foreach(QAbstractAxis* axis, m_axisList) {
                             axis->d_ptr->initializeTheme(m_theme.data(),true);
                         }
                         foreach(QAbstractSeries* series, m_seriesMap.keys()) {
                             series->d_ptr->initializeTheme(m_seriesMap[series],m_theme.data(),true);
                         }
                     }
                 }
             }
             void ChartThemeManager::decorateChart(QChart *chart,ChartTheme* theme,bool force) const
             {
                 QBrush brush;
                 if (force || brush == chart->backgroundBrush())
                     chart->setBackgroundBrush(theme->chartBackgroundGradient());
+                if (force) {
+                    // Always clear plotArea brush when forced update, do not touch otherwise
+                    QPen pen(Qt::transparent);
+                    chart->setPlotAreaBackgroundBrush(brush);
+                    chart->setPlotAreaBackgroundPen(pen);
+                    chart->setPlotAreaBackgroundVisible(false);
+                }
                 chart->setTitleFont(theme->masterFont());
                 chart->setTitleBrush(theme->labelBrush());
                 chart->setDropShadowEnabled(theme->isBackgroundDropShadowEnabled());
             }
             void ChartThemeManager::decorateLegend(QLegend *legend, ChartTheme* theme, bool force) const
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (force || pen == legend->pen())
                     legend->setPen(theme->axisLinePen());
                 if (force || brush == legend->brush())
                     legend->setBrush(theme->chartBackgroundGradient());
                 if (force || font == legend->font())
                     legend->setFont(theme->labelFont());
                 if (force || brush == legend->labelBrush())
                     legend->setLabelBrush(theme->labelBrush());
             }
             int  ChartThemeManager::createIndexKey(QList<int> keys) const
             {
                 qSort(keys);
                 int key = 0;
                 QList<int>::iterator i;
                 i = keys.begin();
                 while (i != keys.end()) {
                     if (*i != key)
                         break;
                     key++;
                     i++;
                 }
                 return key;
             }
             int ChartThemeManager::seriesCount(QAbstractSeries::SeriesType type) const
             {
                 int count = 0;
                 QList<QAbstractSeries *> series =   m_seriesMap.keys();
                 foreach(QAbstractSeries *s, series) {
                     if (s->type() == type)
                         count++;
                 }
                 return count;
             }
             void ChartThemeManager::handleSeriesAdded(QAbstractSeries *series)
             {
                 int key = createIndexKey(m_seriesMap.values());
                 m_seriesMap.insert(series,key);
                 series->d_ptr->initializeTheme(key,m_theme.data(),false);
             }
             void ChartThemeManager::handleSeriesRemoved(QAbstractSeries *series)
             {
                 m_seriesMap.remove(series);
             }
             void ChartThemeManager::handleAxisAdded(QAbstractAxis *axis)
             {
                 m_axisList.append(axis);
                 axis->d_ptr->initializeTheme(m_theme.data(),false);
             }
             void ChartThemeManager::handleAxisRemoved(QAbstractAxis *axis)
             {
                 m_axisList.removeAll(axis);
             }
             void ChartThemeManager::updateSeries(QAbstractSeries *series)
             {
                 if(m_seriesMap.contains(series)){
                     series->d_ptr->initializeTheme(m_seriesMap[series],m_theme.data(),false);
                 }
             }
             QList<QGradient> ChartThemeManager::generateSeriesGradients(const QList<QColor>& colors)
             {
                 QList<QGradient> result;
                 // Generate gradients in HSV color space
                 foreach (const QColor &color, colors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     result << g;
                 }
                 return result;
             }
             QColor ChartThemeManager::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartThemeManager::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             #include "moc_chartthememanager_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/layout/abstractchartlayout.cpp +4 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 "abstractchartlayout_p.h"
             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
             #include "chartaxiselement_p.h"
             #include "charttitle_p.h"
             #include "chartbackground_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             static const qreal golden_ratio = 0.4;
             AbstractChartLayout::AbstractChartLayout(ChartPresenter *presenter)
                 : m_presenter(presenter),
                   m_margins(20, 20, 20, 20),
                   m_minChartRect(0, 0, 200, 200)
             {
             }
             AbstractChartLayout::~AbstractChartLayout()
             {
             }
             void AbstractChartLayout::setGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QList<ChartAxisElement *> axes = m_presenter->axisItems();
                 ChartTitle *title = m_presenter->titleElement();
                 QLegend *legend = m_presenter->legend();
                 ChartBackground *background = m_presenter->backgroundElement();
                 QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
                 contentGeometry = calculateContentGeometry(contentGeometry);
                 if (title && title->isVisible())
                     contentGeometry = calculateTitleGeometry(contentGeometry, title);
                 if (legend->isAttachedToChart() && legend->isVisible())
                     contentGeometry = calculateLegendGeometry(contentGeometry, legend);
                 contentGeometry = calculateAxisGeometry(contentGeometry, axes);
                 m_presenter->setGeometry(contentGeometry);
+                if (m_presenter->chart()->chartType() == QChart::ChartTypeCartesian)
+                    static_cast<QGraphicsRectItem *>(m_presenter->plotAreaElement())->setRect(contentGeometry);
+                else
+                    static_cast<QGraphicsEllipseItem *>(m_presenter->plotAreaElement())->setRect(contentGeometry);
                 QGraphicsLayout::setGeometry(rect);
             }
             QRectF AbstractChartLayout::calculateContentGeometry(const QRectF &geometry) const
             {
                 return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
             }
             QRectF AbstractChartLayout::calculateContentMinimum(const QRectF &minimum) const
             {
                 return  minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
             }
             QRectF AbstractChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
             {
                 qreal left;
                 qreal top;
                 qreal right;
                 qreal bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
                 if (background)
                     background->setRect(backgroundGeometry);
                 return backgroundGeometry;
             }
             QRectF AbstractChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
             {
                 qreal left;
                 qreal top;
                 qreal right;
                 qreal bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 return minimum.adjusted(0, 0, left + right, top + bottom);
             }
             QRectF AbstractChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
                 QRectF legendRect;
                 QRectF result;
                 switch (legend->alignment()) {
                 case Qt::AlignTop: {
                     legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, legendRect.height(), 0, 0);
                     break;
                 }
                 case Qt::AlignBottom: {
                     legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, 0, 0, -legendRect.height());
                     break;
                 }
                 case Qt::AlignLeft: {
                     qreal width = qMin(size.width(), geometry.width() * golden_ratio);
                     legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(width, 0, 0, 0);
                     break;
                 }
                 case Qt::AlignRight: {
                     qreal width = qMin(size.width(), geometry.width() * golden_ratio);
                     legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(0, 0, -width, 0);
                     break;
                 }
                 default: {
                     legendRect = QRectF(0, 0, 0, 0);
                     result = geometry;
                     break;
                 }
                 }
                 legend->setGeometry(legendRect);
                 return result;
             }
             QRectF AbstractChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
                 return geometry.adjusted(0, 0, minSize.width(), minSize.height());
             }
             QRectF AbstractChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
             {
                 title->setGeometry(geometry);
                 QPointF center = geometry.center() - title->boundingRect().center();
                 title->setPos(center.x(), title->pos().y());
                 return geometry.adjusted(0, title->boundingRect().height()+1, 0, 0);
             }
             QRectF AbstractChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
             {
                 QSizeF min = title->sizeHint(Qt::MinimumSize);
                 return  minimum.adjusted(0, 0, min.width(), min.height());
             }
             QSizeF AbstractChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 if (which == Qt::MinimumSize) {
                     QList<ChartAxisElement *> axes = m_presenter->axisItems();
                     ChartTitle *title = m_presenter->titleElement();
                     QLegend *legend = m_presenter->legend();
                     QRectF minimumRect(0, 0, 0, 0);
                     minimumRect = calculateBackgroundMinimum(minimumRect);
                     minimumRect = calculateContentMinimum(minimumRect);
                     minimumRect = calculateTitleMinimum(minimumRect, title);
                     minimumRect = calculateLegendMinimum(minimumRect, legend);
                     minimumRect = calculateAxisMinimum(minimumRect, axes);
                     return  minimumRect.united(m_minChartRect).size().toSize();
                 }
                 return QSize(-1, -1);
             }
             void AbstractChartLayout::setMargins(const QMargins &margins)
             {
                 if (m_margins != margins) {
                     m_margins = margins;
                     updateGeometry();
                 }
             }
             QMargins AbstractChartLayout::margins() const
             {
                 return m_margins;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +59 -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()
+             \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.
+                \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/qchart.h +7 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$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             #include <QMargins>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAbstractAxis;
             class QLegend;
             class QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(QChart::ChartTheme theme READ theme WRITE setTheme)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible)
                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
                 Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
                 Q_PROPERTY(QChart::ChartType chartType READ chartType)
+                Q_PROPERTY(bool plotAreaBackgroundVisible READ isPlotAreaBackgroundVisible WRITE setPlotAreaBackgroundVisible)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
                 Q_ENUMS(ChartType)
             public:
                 enum ChartType {
                     ChartTypeUndefined = 0,
                     ChartTypeCartesian,
                     ChartTypePolar
                 };
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 QList<QAbstractSeries *> series() const;
                 // *** deprecated ***
                 void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 QAbstractAxis *axisX(QAbstractSeries *series = 0) const;
                 QAbstractAxis *axisY(QAbstractSeries *series = 0) const;
                 // ******************
                 void addAxis(QAbstractAxis *axis, Qt::Alignment alignment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes(Qt::Orientations orientation = Qt::Horizontal|Qt::Vertical, QAbstractSeries *series = 0) const;
                 void createDefaultAxes();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setDropShadowEnabled(bool enabled = true);
                 bool isDropShadowEnabled() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomOut();
                 void zoomIn(const QRectF &rect);
                 void zoom(qreal factor);
                 void scroll(qreal dx, qreal dy);
                 QLegend *legend() const;
                 void setMinimumMargins(const QMargins& margins);
                 QMargins minimumMargins() const;
                 void setMargins(const QMargins &margins);
                 QMargins margins() const;
                 QRectF plotArea() const;
+                void setPlotAreaBackgroundBrush(const QBrush &brush);
+                QBrush plotAreaBackgroundBrush() const;
+                void setPlotAreaBackgroundPen(const QPen &pen);
+                QPen plotAreaBackgroundPen() const;
+                void setPlotAreaBackgroundVisible(bool visible = true);
+                bool isPlotAreaBackgroundVisible() const;
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
                 ChartType chartType() const;
             protected:
                 explicit QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags);
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class DeclarativeChart;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class QAbstractSeries;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif // QCHART_H

tests/auto/qchart/tst_qchart.cpp +52 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 <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qabstractbarseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qvalueaxis.h>
             #include <qbarcategoryaxis.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
+                void plotAreaBackgroundBrush_data();
+                void plotAreaBackgroundBrush();
+                void plotAreaBackgroundPen_data();
+                void plotAreaBackgroundPen();
+                void isPlotAreaBackgroundVisible_data();
+                void isPlotAreaBackgroundVisible();
                 void legend_data();
                 void legend();
                 void plotArea_data();
                 void plotArea();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scroll_right_data();
                 void scroll_right();
                 void scroll_left_data();
                 void scroll_left();
                 void scroll_up_data();
                 void scroll_up();
                 void scroll_down_data();
                 void scroll_down();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
                 void createDefaultAxesForLineSeries_data();
                 void createDefaultAxesForLineSeries();
                 void axisPolarOrientation();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::createTestData()
             {
                  QLineSeries* series0 = new QLineSeries(this);
                  *series0 << QPointF(0, 0) << QPointF(100, 100);
                  m_chart->addSeries(series0);
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(!m_chart->axisX());
                 QVERIFY(!m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->plotArea().top()==0);
                 QVERIFY(m_chart->plotArea().left()==0);
                 QVERIFY(m_chart->plotArea().right()==0);
                 QVERIFY(m_chart->plotArea().bottom()==0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scroll(0,0);
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
                 m_view->show();
                 QVERIFY(m_chart->plotArea().top()>0);
                 QVERIFY(m_chart->plotArea().left()>0);
                 QVERIFY(m_chart->plotArea().right()>0);
                 QVERIFY(m_chart->plotArea().bottom()>0);
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QTest::newRow("lineSeries") << line;
                 QTest::newRow("areaSeries") << area;
                 QTest::newRow("scatterSeries") << scatter;
                 QTest::newRow("splineSeries") << spline;
                 if (!isPolarTest()) {
                     QAbstractSeries* pie = new QPieSeries(this);
                     QAbstractSeries* bar = new QBarSeries(this);
                     QAbstractSeries* percent = new QPercentBarSeries(this);
                     QAbstractSeries* stacked = new QStackedBarSeries(this);
                     QTest::newRow("pieSeries") << pie;
                     QTest::newRow("barSeries") << bar;
                     QTest::newRow("percentBarSeries") << percent;
                     QTest::newRow("stackedBarSeries") << stacked;
                 }
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
                 m_chart->addSeries(series);
                 QCOMPARE(m_chart->series().count(), 1);
                 QCOMPARE(m_chart->series().first(), series);
                 QVERIFY(series->chart() == m_chart);
                 m_chart->createDefaultAxes();
                 if(series->type()!=QAbstractSeries::SeriesTypePie){
                     QVERIFY(m_chart->axisY(series));
                     QVERIFY(m_chart->axisX(series));
                 }else{
                     QVERIFY(!m_chart->axisY(series));
                     QVERIFY(!m_chart->axisX(series));
                 }
                 m_chart->removeSeries(series);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::newRow("categories,lineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
                 if (!isPolarTest()) {
                     QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
                     QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
                     QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                     QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 }
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() <<  (QAbstractSeries*) new QSplineSeries(this);
                 if (!isPolarTest()) {
                     QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
                     QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
                     QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                     QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 }
             }
             void tst_QChart::axisX()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisX());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisX(axis,series);
                 QVERIFY(m_chart->axisX(series)==axis);
             }
             void tst_QChart::axisY_data()
             {
                 axisX_data();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisY());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QVERIFY(m_chart->axisY(series)==axis);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
+            void tst_QChart::plotAreaBackgroundBrush_data()
+            {
+                QTest::addColumn<QBrush>("plotAreaBackgroundBrush");
+                QTest::newRow("null") << QBrush();
+                QTest::newRow("blue") << QBrush(Qt::blue);
+                QTest::newRow("white") << QBrush(Qt::white);
+                QTest::newRow("black") << QBrush(Qt::black);
+            }
+            void tst_QChart::plotAreaBackgroundBrush()
+            {
+                QFETCH(QBrush, plotAreaBackgroundBrush);
+                m_chart->setPlotAreaBackgroundBrush(plotAreaBackgroundBrush);
+                QCOMPARE(m_chart->plotAreaBackgroundBrush(), plotAreaBackgroundBrush);
+            }
+            void tst_QChart::plotAreaBackgroundPen_data()
+            {
+                QTest::addColumn<QPen>("plotAreaBackgroundPen");
+                QTest::newRow("null") << QPen();
+                QTest::newRow("blue") << QPen(Qt::blue);
+                QTest::newRow("white") << QPen(Qt::white);
+                QTest::newRow("black") << QPen(Qt::black);
+            }
+            void tst_QChart::plotAreaBackgroundPen()
+            {
+                QFETCH(QPen, plotAreaBackgroundPen);
+                m_chart->setPlotAreaBackgroundPen(plotAreaBackgroundPen);
+                QCOMPARE(m_chart->plotAreaBackgroundPen(), plotAreaBackgroundPen);
+            }
+            void tst_QChart::isPlotAreaBackgroundVisible_data()
+            {
+                QTest::addColumn<bool>("isPlotAreaBackgroundVisible");
+                QTest::newRow("true") << true;
+                QTest::newRow("false") << false;
+            }
+            void tst_QChart::isPlotAreaBackgroundVisible()
+            {
+                QFETCH(bool, isPlotAreaBackgroundVisible);
+                m_chart->setPlotAreaBackgroundVisible(isPlotAreaBackgroundVisible);
+                QCOMPARE(m_chart->isPlotAreaBackgroundVisible(), isPlotAreaBackgroundVisible);
+            }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::plotArea_data()
             {
             }
             void tst_QChart::plotArea()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->plotArea().isValid());
                 QVERIFY(m_chart->plotArea().height() < rect.height());
                 QVERIFY(m_chart->plotArea().width() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->createDefaultAxes();
                 QCOMPARE(m_chart->axes().count(), 2);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QCOMPARE(m_chart->axes().count(), 2);
                 QVERIFY(m_chart->axisX() != 0);
                 QVERIFY(m_chart->axisY() != 0);
                 QCOMPARE(deleteSpy1.count(), 1);
                 QCOMPARE(deleteSpy2.count(), 1);
                 QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 axisX_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractAxis *, axis);
                 QFETCH(QAbstractSeries *, series);
                 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QCOMPARE(m_chart->axes().count(), 1);
                 QVERIFY(m_chart->axisY() != 0);
                 QVERIFY(m_chart->axisY(series)==0);
                 QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scroll_right_data()
             {
                  QTest::addColumn<QAbstractSeries *>("series");
                  QLineSeries* series0 = new QLineSeries(this);
                  *series0 << QPointF(0, 0) << QPointF(100, 100);
                  QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
             }
             void tst_QChart::scroll_right()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisX();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                         QVERIFY(vaxis!=0);
                         qreal min = vaxis->min();
                         qreal max = vaxis->max();
                         QVERIFY(max>min);
                         m_chart->scroll(50, 0);
                         QVERIFY(min<vaxis->min());
                         QVERIFY(max<vaxis->max());
                         break;
                     }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                         QVERIFY(caxis!=0);
                         qreal min = caxis->min().toDouble();
                         qreal max = caxis->max().toDouble();
                         m_chart->scroll(50, 0);
                         QVERIFY(min<caxis->min().toDouble());
                         QVERIFY(max<caxis->max().toDouble());
                         break;
                     }
                     default:
                         qFatal("Unsupported type");
                         break;
                 }
             }
             void tst_QChart::scroll_left_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_left()
             {
                  QFETCH(QAbstractSeries *, series);
                  m_chart->addSeries(series);
                  m_chart->createDefaultAxes();
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
                  QAbstractAxis * axis = m_chart->axisX();
                  QVERIFY(axis!=0);
                  switch(axis->type())
                     {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                             QVERIFY(vaxis!=0);
                             qreal min = vaxis->min();
                             qreal max = vaxis->max();
                             m_chart->scroll(-50, 0);
                             QVERIFY(min>vaxis->min());
                             QVERIFY(max>vaxis->max());
                             break;
                         }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                             QVERIFY(caxis!=0);
                             qreal min = caxis->min().toDouble();
                             qreal max = caxis->max().toDouble();
                             m_chart->scroll(-50, 0);
                             QVERIFY(min>caxis->min().toDouble());
                             QVERIFY(max>caxis->max().toDouble());
                             break;
                         }
                         default:
                             qFatal("Unsupported type");
                             break;
                     }
             }
             void tst_QChart::scroll_up_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_up()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisY();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                         QVERIFY(vaxis!=0);
                         qreal min = vaxis->min();
                         qreal max = vaxis->max();
                         m_chart->scroll(0, 50);
                         QVERIFY(min<vaxis->min());
                         QVERIFY(max<vaxis->max());
                         break;
                     }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                         QVERIFY(caxis!=0);
                         qreal min = caxis->min().toDouble();
                         qreal max = caxis->max().toDouble();
                         m_chart->scroll(0, 50);
                         QVERIFY(min<caxis->min().toDouble());
                         QVERIFY(max<caxis->max().toDouble());
                         break;
                     }
                     default:
                         qFatal("Unsupported type");
                         break;
                 }
             }
             void tst_QChart::scroll_down_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_down()
             {
                  QFETCH(QAbstractSeries *, series);
                  m_chart->addSeries(series);
                  m_chart->createDefaultAxes();
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
                  QAbstractAxis * axis = m_chart->axisY();
                  QVERIFY(axis!=0);
                  switch(axis->type())
                     {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                             QVERIFY(vaxis!=0);
                             qreal min = vaxis->min();
                             qreal max = vaxis->max();
                             m_chart->scroll(0, -50);
                             QVERIFY(min>vaxis->min());
                             QVERIFY(max>vaxis->max());
                             break;
                         }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                             QVERIFY(caxis!=0);
                             qreal min = caxis->min().toDouble();
                             qreal max = caxis->max().toDouble();
                             m_chart->scroll(0, -50);
                             QVERIFY(min>caxis->min().toDouble());
                             QVERIFY(max>caxis->max().toDouble());
                             break;
                         }
                         default:
                             qFatal("Unsupported type");
                             break;
                     }
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 m_chart->createDefaultAxes();
                 QRectF marigns = m_chart->plotArea();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<axisX->min());
                     QVERIFY(maxX>axisX->max());
                     QVERIFY(minY<axisY->min());
                     QVERIFY(maxY>axisY->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 m_chart->createDefaultAxes();
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < axisX->min());
                 QVERIFY(maxX > axisX->max());
                 QVERIFY(minY < axisY->min());
                 QVERIFY(maxY > axisY->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(axisX->min()));
                 else
                     QCOMPARE(minX, axisX->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(axisY->min()));
                 else
                     QCOMPARE(minY, axisY->min());
                 QVERIFY(maxX == axisX->max());
                 QVERIFY(maxY == axisY->max());
             }
             void tst_QChart::createDefaultAxesForLineSeries_data()
             {
                 QTest::addColumn<qreal>("series1minX");
                 QTest::addColumn<qreal>("series1midX");
                 QTest::addColumn<qreal>("series1maxX");
                 QTest::addColumn<qreal>("series2minX");
                 QTest::addColumn<qreal>("series2midX");
                 QTest::addColumn<qreal>("series2maxX");
                 QTest::addColumn<qreal>("overallminX");
                 QTest::addColumn<qreal>("overallmaxX");
                 QTest::addColumn<qreal>("series1minY");
                 QTest::addColumn<qreal>("series1midY");
                 QTest::addColumn<qreal>("series1maxY");
                 QTest::addColumn<qreal>("series2minY");
                 QTest::addColumn<qreal>("series2midY");
                 QTest::addColumn<qreal>("series2maxY");
                 QTest::addColumn<qreal>("overallminY");
                 QTest::addColumn<qreal>("overallmaxY");
                 QTest::newRow("series1hasMinAndMax") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0
                                                      << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0;
                 QTest::newRow("series2hasMinAndMax") << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0
                                                      << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
                 QTest::newRow("series1hasMinAndMaxX_series2hasMinAndMaxY") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0
                                                                            << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
                 QTest::newRow("series1hasMin_series2hasMax") << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0
                                                              << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
                 QTest::newRow("bothSeriesHaveSameMinAndMax") << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0
                                                              << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)0.6 << (qreal)1.6;
             }
             void tst_QChart::createDefaultAxesForLineSeries()
             {
                 QFETCH(qreal, series1minX);
                 QFETCH(qreal, series1midX);
                 QFETCH(qreal, series1maxX);
                 QFETCH(qreal, series2minX);
                 QFETCH(qreal, series2midX);
                 QFETCH(qreal, series2maxX);
                 QFETCH(qreal, series1minY);
                 QFETCH(qreal, series1midY);
                 QFETCH(qreal, series1maxY);
                 QFETCH(qreal, series2minY);
                 QFETCH(qreal, series2midY);
                 QFETCH(qreal, series2maxY);
                 QFETCH(qreal, overallminX);
                 QFETCH(qreal, overallmaxX);
                 QFETCH(qreal, overallminY);
                 QFETCH(qreal, overallmaxY);
                 QLineSeries* series1 = new QLineSeries(this);
                 series1->append(series1minX, series1minY);
                 series1->append(series1midX, series1midY);
                 series1->append(series1maxX, series1maxY);
                 QLineSeries* series2 = new QLineSeries(this);
                 series2->append(series2minX, series2minY);
                 series2->append(series2midX, series2midY);
                 series2->append(series2maxX, series2maxY);
                 QChart *chart = newQChartOrQPolarChart();
                 chart->addSeries(series1);
                 chart->addSeries(series2);
                 chart->createDefaultAxes();
                 QValueAxis *xAxis = (QValueAxis *)chart->axisX();
                 QCOMPARE(xAxis->min(), overallminX);
                 QCOMPARE(xAxis->max(), overallmaxX);
                 QValueAxis *yAxis = (QValueAxis *)chart->axisY();
                 QCOMPARE(yAxis->min(), overallminY);
                 QCOMPARE(yAxis->max(), overallmaxY);
                 QLineSeries *series3 = new QLineSeries(this);
                 // Numbers clearly out of existing range
                 series3->append(0, 0);
                 series3->append(100, 100);
                 // Adding a new series should not change the axes as they have not been told to update
                 chart->addSeries(series3);
                 QCOMPARE(xAxis->min(), overallminX);
                 QCOMPARE(xAxis->max(), overallmaxX);
                 QCOMPARE(yAxis->min(), overallminY);
                 QCOMPARE(yAxis->max(), overallmaxY);
             }
             void tst_QChart::axisPolarOrientation()
             {
                 QLineSeries* series1 = new QLineSeries(this);
                 series1->append(1, 2);
                 series1->append(2, 4);
                 series1->append(3, 8);
                 QPolarChart chart;
                 chart.addSeries(series1);
                 QValueAxis *xAxis = new QValueAxis();
                 QValueAxis *yAxis = new QValueAxis();
                 chart.addAxis(xAxis, QPolarChart::PolarOrientationAngular);
                 chart.addAxis(yAxis, QPolarChart::PolarOrientationRadial);
                 QList<QAbstractAxis *> xAxes = chart.axes(QPolarChart::PolarOrientationAngular);
                 QList<QAbstractAxis *> yAxes = chart.axes(QPolarChart::PolarOrientationRadial);
                 QCOMPARE(xAxes.size(), 1);
                 QCOMPARE(yAxes.size(), 1);
                 QCOMPARE(xAxes[0], xAxis);
                 QCOMPARE(yAxes[0], yAxis);
                 QCOMPARE(chart.axisPolarOrientation(xAxes[0]), QPolarChart::PolarOrientationAngular);
                 QCOMPARE(chart.axisPolarOrientation(yAxes[0]), QPolarChart::PolarOrientationRadial);
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

tests/polarcharttest/mainwindow.cpp +63 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 "mainwindow.h"
             #include "chartview.h"
             #include <QScatterSeries>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QDateTimeAxis>
             #include <QCategoryAxis>
             #include <QPolarChart>
             #include <QDebug>
             #include <qmath.h>
             #include <QDateTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "ui_mainwindow.h"
             MainWindow::MainWindow(QWidget *parent) :
                 QMainWindow(parent),
                 ui(new Ui::MainWindow),
                 m_angularTickCount(9),
                 m_radialTickCount(11),
                 m_labelsAngle(0),
                 m_angularMin(0.0),
                 m_angularMax(40000.0),
                 m_radialMin(0.0),
                 m_radialMax(30000.0),
                 m_angularShadesVisible(false),
                 m_radialShadesVisible(false),
                 m_labelsVisible(true),
                 m_titleVisible(true),
                 m_gridVisible(true),
                 m_arrowVisible(true),
                 m_angularShadesBrush(new QBrush(Qt::NoBrush)),
                 m_radialShadesBrush(new QBrush(Qt::NoBrush)),
                 m_labelBrush(new QBrush(Qt::black)),
                 m_titleBrush(new QBrush(Qt::black)),
+                m_backgroundBrush(new QBrush(Qt::white)),
+                m_plotAreaBackgroundBrush(new QBrush(Qt::NoBrush)),
                 m_angularShadesPen(new QPen(Qt::NoPen)),
                 m_radialShadesPen(new QPen(Qt::NoPen)),
                 m_labelPen(new QPen(Qt::NoPen)),
                 m_titlePen(new QPen(Qt::NoPen)),
                 m_gridPen(new QPen(QRgb(0x010101))),  // Note: Pure black is default color, so it gets overridden by
                 m_arrowPen(new QPen(QRgb(0x010101))), // default theme if set to that initially. This is an example of workaround.
+                m_backgroundPen(new QPen(Qt::NoPen)),
+                m_plotAreaBackgroundPen(new QPen(Qt::NoPen)),
                 m_labelFormat(QString("%.2f")),
                 m_animationOptions(QChart::NoAnimation),
                 m_angularTitle(QString("Angular Title")),
                 m_radialTitle(QString("Radial Title")),
                 m_base(2.0),
                 m_chart(0),
                 m_angularAxis(0),
                 m_radialAxis(0),
                 m_angularAxisMode(AxisModeNone),
                 m_radialAxisMode(AxisModeNone),
                 m_series1(0),
                 m_series2(0),
                 m_series3(0),
                 m_series4(0),
                 m_series5(0),
                 m_series6(0),
                 m_series7(0),
                 m_dateFormat(QString("mm-ss-zzz")),
                 m_moreCategories(false)
             {
                 ui->setupUi(this);
                 ui->angularTicksSpin->setValue(m_angularTickCount);
                 ui->radialTicksSpin->setValue(m_radialTickCount);
                 ui->anglesSpin->setValue(m_labelsAngle);
                 ui->radialMinSpin->setValue(m_radialMin);
                 ui->radialMaxSpin->setValue(m_radialMax);
                 ui->angularMinSpin->setValue(m_angularMin);
                 ui->angularMaxSpin->setValue(m_angularMax);
                 ui->angularShadesComboBox->setCurrentIndex(0);
                 ui->radialShadesComboBox->setCurrentIndex(0);
                 ui->labelFormatEdit->setText(m_labelFormat);
                 ui->dateFormatEdit->setText(m_dateFormat);
                 ui->moreCategoriesCheckBox->setChecked(m_moreCategories);
                 ui->series1checkBox->setChecked(true);
                 ui->series2checkBox->setChecked(true);
                 ui->series3checkBox->setChecked(true);
                 ui->series4checkBox->setChecked(true);
                 ui->series5checkBox->setChecked(true);
                 ui->series6checkBox->setChecked(true);
                 ui->series7checkBox->setChecked(true);
                 m_currentLabelFont.setFamily(ui->labelFontComboBox->currentFont().family());
                 m_currentLabelFont.setPixelSize(15);
                 m_currentTitleFont.setFamily(ui->titleFontComboBox->currentFont().family());
                 m_currentTitleFont.setPixelSize(30);
                 ui->labelFontSizeSpin->setValue(m_currentLabelFont.pixelSize());
                 ui->titleFontSizeSpin->setValue(m_currentTitleFont.pixelSize());
                 ui->logBaseSpin->setValue(m_base);
                 initXYValueChart();
                 setAngularAxis(AxisModeValue);
                 setRadialAxis(AxisModeValue);
                 ui->angularAxisComboBox->setCurrentIndex(int(m_angularAxisMode));
                 ui->radialAxisComboBox->setCurrentIndex(int(m_radialAxisMode));
                 connect(ui->angularTicksSpin, SIGNAL(valueChanged(int)), this, SLOT(angularTicksChanged(int)));
                 connect(ui->radialTicksSpin, SIGNAL(valueChanged(int)), this, SLOT(radialTicksChanged(int)));
                 connect(ui->anglesSpin, SIGNAL(valueChanged(int)), this, SLOT(anglesChanged(int)));
                 connect(ui->radialMinSpin, SIGNAL(valueChanged(double)), this, SLOT(radialMinChanged(double)));
                 connect(ui->radialMaxSpin, SIGNAL(valueChanged(double)), this, SLOT(radialMaxChanged(double)));
                 connect(ui->angularMinSpin, SIGNAL(valueChanged(double)), this, SLOT(angularMinChanged(double)));
                 connect(ui->angularMaxSpin, SIGNAL(valueChanged(double)), this, SLOT(angularMaxChanged(double)));
                 connect(ui->angularShadesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(angularShadesIndexChanged(int)));
                 connect(ui->radialShadesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(radialShadesIndexChanged(int)));
                 connect(ui->animationsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(animationIndexChanged(int)));
                 connect(ui->labelFormatEdit, SIGNAL(textEdited(QString)), this, SLOT(labelFormatEdited(QString)));
                 connect(ui->labelFontComboBox, SIGNAL(currentFontChanged(QFont)), this, SLOT(labelFontChanged(QFont)));
                 connect(ui->labelFontSizeSpin, SIGNAL(valueChanged(int)), this, SLOT(labelFontSizeChanged(int)));
                 connect(ui->labelComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(labelsIndexChanged(int)));
                 connect(ui->titleFontComboBox, SIGNAL(currentFontChanged(QFont)), this, SLOT(titleFontChanged(QFont)));
                 connect(ui->titleFontSizeSpin, SIGNAL(valueChanged(int)), this, SLOT(titleFontSizeChanged(int)));
                 connect(ui->titleComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(titleIndexChanged(int)));
                 connect(ui->gridComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(gridIndexChanged(int)));
                 connect(ui->arrowComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(arrowIndexChanged(int)));
                 connect(ui->logBaseSpin, SIGNAL(valueChanged(double)), this, SLOT(logBaseChanged(double)));
                 connect(ui->angularAxisComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(angularAxisIndexChanged(int)));
                 connect(ui->radialAxisComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(radialAxisIndexChanged(int)));
                 connect(ui->niceNumbersCheckBox, SIGNAL(clicked()), this, SLOT(niceNumbersChecked()));
                 connect(ui->dateFormatEdit, SIGNAL(textEdited(QString)), this, SLOT(dateFormatEdited(QString)));
                 connect(ui->moreCategoriesCheckBox, SIGNAL(clicked()), this, SLOT(moreCategoriesChecked()));
                 connect(ui->series1checkBox, SIGNAL(clicked()), this, SLOT(series1CheckBoxChecked()));
                 connect(ui->series2checkBox, SIGNAL(clicked()), this, SLOT(series2CheckBoxChecked()));
                 connect(ui->series3checkBox, SIGNAL(clicked()), this, SLOT(series3CheckBoxChecked()));
                 connect(ui->series4checkBox, SIGNAL(clicked()), this, SLOT(series4CheckBoxChecked()));
                 connect(ui->series5checkBox, SIGNAL(clicked()), this, SLOT(series5CheckBoxChecked()));
                 connect(ui->series6checkBox, SIGNAL(clicked()), this, SLOT(series6CheckBoxChecked()));
                 connect(ui->series7checkBox, SIGNAL(clicked()), this, SLOT(series7CheckBoxChecked()));
                 connect(ui->themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(themeIndexChanged(int)));
+                connect(ui->backgroundComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(backgroundIndexChanged(int)));
+                connect(ui->plotAreaComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(plotAreaIndexChanged(int)));
                 ui->chartView->setChart(m_chart);
                 ui->chartView->setRenderHint(QPainter::Antialiasing);
             }
             MainWindow::~MainWindow()
             {
                 delete ui;
                 delete m_angularShadesBrush;
                 delete m_radialShadesBrush;
                 delete m_angularShadesPen;
                 delete m_radialShadesPen;
             }
             void MainWindow::initXYValueChart()
             {
                 qreal seriesAngularMin = 1;
                 qreal seriesAngularMax = 46000;
                 qreal seriesRadialMin = 1;
                 qreal seriesRadialMax = 23500;
                 qreal radialDimension = seriesRadialMax - seriesRadialMin;
                 qreal angularDimension = seriesAngularMax - seriesAngularMin;
                 // Scatter series, points outside min-max ranges should not be drawn
                 m_series1 = new QScatterSeries();
                 m_series1->setName("scatter");
                 qreal scatterCount = 10;
                 qreal scatterAngularStep = angularDimension / scatterCount;
                 qreal scatterRadialStep = radialDimension / scatterCount;
                 for (qreal i = 0.0; i < scatterCount; i++) {
                     m_series1->append((i * scatterAngularStep) + seriesAngularMin, (i * scatterRadialStep) + seriesRadialMin);
                     //qDebug() << m_series1->points().last();
                 }
                 m_series1->setMarkerSize(10);
                 *m_series1 << QPointF(50, 50) << QPointF(150, 150) << QPointF(250, 250) << QPointF(350, 350) << QPointF(450, 450);
                 *m_series1 << QPointF(1050, 0.50) << QPointF(1150, 0.25) << QPointF(1250, 0.12) << QPointF(1350, 0.075) << QPointF(1450, 0.036);
                 *m_series1 << QPointF(0.50, 2000) << QPointF(0.25, 3500) << QPointF(0.12, 5000) << QPointF(0.075, 6500) << QPointF(0.036, 8000);
                 // Line series, points outside min-max ranges should not be drawn,
                 // but lines should be properly interpolated at chart edges
                 m_series2 = new QLineSeries();
                 m_series2->setName("line 1");
                 qreal lineCount = 100;
                 qreal lineAngularStep = angularDimension / lineCount;
                 qreal lineRadialStep = radialDimension / lineCount;
                 for (qreal i = 0.0; i < lineCount; i++) {
                     m_series2->append((i * lineAngularStep) + seriesAngularMin, (i * lineRadialStep) + seriesRadialMin);
                     //qDebug() << m_series2->points().last();
                 }
                 QPen series2Pen = QPen(Qt::blue, 10);
                 //series2Pen.setStyle(Qt::DashDotDotLine);
                 m_series2->setPen(series2Pen);
                 m_series3 = new QLineSeries();
                 m_series3->setName("Area upper");
                 lineCount = 87;
                 lineAngularStep = angularDimension / lineCount;
                 lineRadialStep = radialDimension / lineCount;
                 for (qreal i = 1.0; i <= lineCount; i++) {
                     m_series3->append((i * lineAngularStep) + seriesAngularMin, (i * lineRadialStep) + seriesRadialMin + 200.0);
                     //qDebug() << m_series3->points().last();
                 }
                 m_series4 = new QLineSeries();
                 m_series4->setName("Area lower");
                 lineCount = 89;
                 lineAngularStep = angularDimension / lineCount;
                 lineRadialStep = radialDimension / lineCount;
                 for (qreal i = 1.0; i <= lineCount; i++) {
                     m_series4->append((i * lineAngularStep) + seriesAngularMin + 100.0, (i * lineRadialStep) + seriesRadialMin + i * 300.0);
                     //qDebug() << m_series4->points().last();
                 }
                 m_series5 = new QAreaSeries();
                 m_series5->setName("area");
                 m_series5->setUpperSeries(m_series3);
                 m_series5->setLowerSeries(m_series4);
                 m_series5->setOpacity(0.5);
                 m_series6 = new QSplineSeries();
                 m_series6->setName("spline");
                 qreal ad = angularDimension / 20;
                 qreal rd = radialDimension / 10;
                 m_series6->append(seriesAngularMin, seriesRadialMin + rd * 2);
                 m_series6->append(seriesAngularMin + ad, seriesRadialMin + rd * 5);
                 m_series6->append(seriesAngularMin + ad * 2, seriesRadialMin + rd * 4);
                 m_series6->append(seriesAngularMin + ad * 3, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 4, seriesRadialMin + rd * 11);
                 m_series6->append(seriesAngularMin + ad * 5, seriesRadialMin + rd * 12);
                 m_series6->append(seriesAngularMin + ad * 6, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 7, seriesRadialMin + rd * 11);
                 m_series6->append(seriesAngularMin + ad * 8, seriesRadialMin + rd * 12);
                 m_series6->append(seriesAngularMin + ad * 9, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 4);
                 m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 8);
                 m_series6->append(seriesAngularMin + ad * 11, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 12, seriesRadialMin + rd * 11);
                 m_series6->append(seriesAngularMin + ad * 13, seriesRadialMin + rd * 12);
                 m_series6->append(seriesAngularMin + ad * 14, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 15, seriesRadialMin + rd * 3);
                 m_series6->append(seriesAngularMin + ad * 16, seriesRadialMin + rd * 2);
                 m_series6->append(seriesAngularMin + ad * 17, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 18, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 19, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 20, seriesRadialMin + rd * 6);
                 m_series6->append(seriesAngularMin + ad * 19, seriesRadialMin + rd * 2);
                 m_series6->append(seriesAngularMin + ad * 18, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 17, seriesRadialMin + rd * 7);
                 m_series6->append(seriesAngularMin + ad * 16, seriesRadialMin + rd * 3);
                 m_series6->append(seriesAngularMin + ad * 15, seriesRadialMin + rd * 1);
                 m_series6->append(seriesAngularMin + ad * 14, seriesRadialMin + rd * 7);
                 m_series6->append(seriesAngularMin + ad * 13, seriesRadialMin + rd * 5);
                 m_series6->append(seriesAngularMin + ad * 12, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 11, seriesRadialMin + rd * 1);
                 m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 4);
                 m_series6->append(seriesAngularMin + ad * 9, seriesRadialMin + rd * 1);
                 m_series6->append(seriesAngularMin + ad * 8, seriesRadialMin + rd * 2);
                 m_series6->append(seriesAngularMin + ad * 7, seriesRadialMin + rd * 4);
                 m_series6->append(seriesAngularMin + ad * 6, seriesRadialMin + rd * 8);
                 m_series6->append(seriesAngularMin + ad * 5, seriesRadialMin + rd * 12);
                 m_series6->append(seriesAngularMin + ad * 4, seriesRadialMin + rd * 9);
                 m_series6->append(seriesAngularMin + ad * 3, seriesRadialMin + rd * 8);
                 m_series6->append(seriesAngularMin + ad * 2, seriesRadialMin + rd * 7);
                 m_series6->append(seriesAngularMin + ad, seriesRadialMin + rd * 4);
                 m_series6->append(seriesAngularMin, seriesRadialMin + rd * 10);
                 m_series6->setPointsVisible(true);
                 QPen series6Pen = QPen(Qt::red, 10);
                 //series6Pen.setStyle(Qt::DashDotDotLine);
                 m_series6->setPen(series6Pen);
                 // m_series7 shows points at category intersections
                 m_series7 = new QScatterSeries();
                 m_series7->setName("Category check");
                 m_series7->setMarkerSize(7);
                 m_series7->setBrush(QColor(Qt::red));
                 m_series7->setMarkerShape(QScatterSeries::MarkerShapeRectangle);
                 *m_series7 << QPointF(1000, 1000)
                            << QPointF(1000, 2000)
                            << QPointF(1000, 4000)
                            << QPointF(1000, 9000)
                            << QPointF(1000, 14000)
                            << QPointF(1000, 16500)
                            << QPointF(1000, 19000)
                            << QPointF(4000, 1000)
                            << QPointF(4000, 2000)
                            << QPointF(4000, 4000)
                            << QPointF(4000, 9000)
                            << QPointF(4000, 14000)
                            << QPointF(4000, 16500)
                            << QPointF(4000, 19000)
                            << QPointF(7000, 1000)
                            << QPointF(7000, 2000)
                            << QPointF(7000, 4000)
                            << QPointF(7000, 9000)
                            << QPointF(7000, 14000)
                            << QPointF(7000, 16500)
                            << QPointF(7000, 19000)
                            << QPointF(12000, 1000)
                            << QPointF(12000, 2000)
                            << QPointF(12000, 4000)
                            << QPointF(12000, 9000)
                            << QPointF(12000, 14000)
                            << QPointF(12000, 16500)
                            << QPointF(12000, 19000)
                            << QPointF(17000, 1000)
                            << QPointF(17000, 2000)
                            << QPointF(17000, 4000)
                            << QPointF(17000, 9000)
                            << QPointF(17000, 14000)
                            << QPointF(17000, 16500)
                            << QPointF(17000, 19000)
                            << QPointF(22000, 1000)
                            << QPointF(22000, 2000)
                            << QPointF(22000, 4000)
                            << QPointF(22000, 9000)
                            << QPointF(22000, 14000)
                            << QPointF(22000, 16500)
                            << QPointF(22000, 19000)
                            << QPointF(28000, 1000)
                            << QPointF(28000, 2000)
                            << QPointF(28000, 4000)
                            << QPointF(28000, 9000)
                            << QPointF(28000, 14000)
                            << QPointF(28000, 16500)
                            << QPointF(28000, 19000);
                 m_chart = new QPolarChart();
                 m_chart->addSeries(m_series1);
                 m_chart->addSeries(m_series2);
                 m_chart->addSeries(m_series3);
                 m_chart->addSeries(m_series4);
                 m_chart->addSeries(m_series5);
                 m_chart->addSeries(m_series6);
                 m_chart->addSeries(m_series7);
                 connect(m_series1, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series2, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series3, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series4, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series5, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series6, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series7, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
                 connect(m_series1, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series2, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series3, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series4, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series5, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series6, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 connect(m_series7, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
                 m_chart->setTitle("Use arrow keys to scroll and +/- to zoom");
                 m_chart->setAnimationOptions(m_animationOptions);
                 //m_chart->legend()->setVisible(false);
                 m_chart->setAcceptHoverEvents(true);
+                m_chart->setBackgroundBrush(*m_backgroundBrush);
+                m_chart->setBackgroundPen(*m_backgroundPen);
+                m_chart->setPlotAreaBackgroundBrush(*m_plotAreaBackgroundBrush);
+                m_chart->setPlotAreaBackgroundPen(*m_plotAreaBackgroundPen);
             }
             void MainWindow::setAngularAxis(MainWindow::AxisMode mode)
             {
                 if (m_angularAxis) {
                     m_chart->removeAxis(m_angularAxis);
                     delete m_angularAxis;
                     m_angularAxis = 0;
                 }
                 m_angularAxisMode = mode;
                 switch (m_angularAxisMode) {
                 case AxisModeNone:
                     return;
                 case AxisModeValue:
                     m_angularAxis = new QValueAxis();
                     static_cast<QValueAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
                     static_cast<QValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
                     break;
                 case AxisModeLogValue:
                     m_angularAxis = new QLogValueAxis();
                     static_cast<QLogValueAxis *>(m_angularAxis)->setBase(m_base);
                     static_cast<QLogValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
                     break;
                 case AxisModeDateTime:
                     m_angularAxis = new QDateTimeAxis();
                     static_cast<QDateTimeAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
                     static_cast<QDateTimeAxis *>(m_angularAxis)->setFormat(m_dateFormat);
                     break;
                 case AxisModeCategory:
                     m_angularAxis = new QCategoryAxis();
                     applyCategories();
                     break;
                 default:
                     qWarning() << "Unsupported AxisMode";
                     break;
                 }
                 m_angularAxis->setLabelsAngle(m_labelsAngle);
                 m_angularAxis->setLabelsFont(m_currentLabelFont);
                 m_angularAxis->setLabelsBrush(*m_labelBrush);
                 m_angularAxis->setLabelsPen(*m_labelPen);
                 m_angularAxis->setLabelsVisible(m_labelsVisible);
                 m_angularAxis->setShadesBrush(*m_angularShadesBrush);
                 m_angularAxis->setShadesPen(*m_angularShadesPen);
                 m_angularAxis->setShadesVisible(m_angularShadesVisible);
                 m_angularAxis->setTitleFont(m_currentTitleFont);
                 m_angularAxis->setTitleBrush(*m_titleBrush);
                 m_angularAxis->setTitlePen(*m_titlePen);
                 m_angularAxis->setTitleVisible(m_titleVisible);
                 m_angularAxis->setTitleText(m_angularTitle);
                 m_angularAxis->setGridLinePen(*m_gridPen);
                 m_angularAxis->setGridLineVisible(m_gridVisible);
                 m_angularAxis->setLinePen(*m_arrowPen);
                 m_angularAxis->setLineVisible(m_arrowVisible);
                 m_chart->addAxis(m_angularAxis, QPolarChart::PolarOrientationAngular);
                 m_series1->attachAxis(m_angularAxis);
                 m_series2->attachAxis(m_angularAxis);
                 m_series3->attachAxis(m_angularAxis);
                 m_series4->attachAxis(m_angularAxis);
                 m_series5->attachAxis(m_angularAxis);
                 m_series6->attachAxis(m_angularAxis);
                 m_series7->attachAxis(m_angularAxis);
                 applyRanges();
                 //connect(m_angularAxis, SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(angularRangeChanged(qreal, qreal)));
             }
             void MainWindow::setRadialAxis(MainWindow::AxisMode mode)
             {
                 if (m_radialAxis) {
                     m_chart->removeAxis(m_radialAxis);
                     delete m_radialAxis;
                     m_radialAxis = 0;
                 }
                 m_radialAxisMode = mode;
                 switch (m_radialAxisMode) {
                 case AxisModeNone:
                     return;
                 case AxisModeValue:
                     m_radialAxis = new QValueAxis();
                     static_cast<QValueAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
                     static_cast<QValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
                     break;
                 case AxisModeLogValue:
                     m_radialAxis = new QLogValueAxis();
                     static_cast<QLogValueAxis *>(m_radialAxis)->setBase(m_base);
                     static_cast<QLogValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
                     break;
                 case AxisModeDateTime:
                     m_radialAxis = new QDateTimeAxis();
                     static_cast<QDateTimeAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
                     static_cast<QDateTimeAxis *>(m_radialAxis)->setFormat(m_dateFormat);
                     break;
                 case AxisModeCategory:
                     m_radialAxis = new QCategoryAxis();
                     applyCategories();
                     break;
                 default:
                     qWarning() << "Unsupported AxisMode";
                     break;
                 }
                 m_radialAxis->setLabelsAngle(m_labelsAngle);
                 m_radialAxis->setLabelsFont(m_currentLabelFont);
                 m_radialAxis->setLabelsBrush(*m_labelBrush);
                 m_radialAxis->setLabelsPen(*m_labelPen);
                 m_radialAxis->setLabelsVisible(m_labelsVisible);
                 m_radialAxis->setShadesBrush(*m_radialShadesBrush);
                 m_radialAxis->setShadesPen(*m_radialShadesPen);
                 m_radialAxis->setShadesVisible(m_radialShadesVisible);
                 m_radialAxis->setTitleFont(m_currentTitleFont);
                 m_radialAxis->setTitleBrush(*m_titleBrush);
                 m_radialAxis->setTitlePen(*m_titlePen);
                 m_radialAxis->setTitleVisible(m_titleVisible);
                 m_radialAxis->setTitleText(m_radialTitle);
                 m_radialAxis->setGridLinePen(*m_gridPen);
                 m_radialAxis->setGridLineVisible(m_gridVisible);
                 m_radialAxis->setLinePen(*m_arrowPen);
                 m_radialAxis->setLineVisible(m_arrowVisible);
                 m_chart->addAxis(m_radialAxis, QPolarChart::PolarOrientationRadial);
                 m_series1->attachAxis(m_radialAxis);
                 m_series2->attachAxis(m_radialAxis);
                 m_series3->attachAxis(m_radialAxis);
                 m_series4->attachAxis(m_radialAxis);
                 m_series5->attachAxis(m_radialAxis);
                 m_series6->attachAxis(m_radialAxis);
                 m_series7->attachAxis(m_radialAxis);
                 applyRanges();
                 series1CheckBoxChecked();
                 series2CheckBoxChecked();
                 series3CheckBoxChecked();
                 series4CheckBoxChecked();
                 series5CheckBoxChecked();
                 series6CheckBoxChecked();
                 series7CheckBoxChecked();
                 //connect(m_radialAxis, SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(radialRangeChanged(qreal, qreal)));
             }
             void MainWindow::applyRanges()
             {
                 if (ui->niceNumbersCheckBox->isChecked()) {
                     if (m_angularAxisMode == AxisModeValue) {
                         static_cast<QValueAxis *>(m_angularAxis)->applyNiceNumbers();
                         m_angularMin = static_cast<QValueAxis *>(m_angularAxis)->min();
                         m_angularMax = static_cast<QValueAxis *>(m_angularAxis)->max();
                         m_angularTickCount = static_cast<QValueAxis *>(m_angularAxis)->tickCount();
                     }
                     if (m_radialAxisMode == AxisModeValue) {
                         static_cast<QValueAxis *>(m_radialAxis)->applyNiceNumbers();
                         m_radialMin = static_cast<QValueAxis *>(m_radialAxis)->min();
                         m_radialMax = static_cast<QValueAxis *>(m_radialAxis)->max();
                         m_radialTickCount = static_cast<QValueAxis *>(m_radialAxis)->tickCount();
                     }
                 }
                 if (m_angularAxis)
                     m_angularAxis->setRange(m_angularMin, m_angularMax);
                 if (m_radialAxis)
                     m_radialAxis->setRange(m_radialMin, m_radialMax);
             }
             void MainWindow::angularTicksChanged(int value)
             {
                 m_angularTickCount = value;
                 if (m_angularAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
                 else if (m_angularAxisMode == AxisModeDateTime)
                     static_cast<QDateTimeAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
             }
             void MainWindow::radialTicksChanged(int value)
             {
                 m_radialTickCount = value;
                 if (m_radialAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
                 else if (m_radialAxisMode == AxisModeDateTime)
                     static_cast<QDateTimeAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
             }
             void MainWindow::anglesChanged(int value)
             {
                 m_labelsAngle = value;
                 m_radialAxis->setLabelsAngle(m_labelsAngle);
                 m_angularAxis->setLabelsAngle(m_labelsAngle);
             }
             void MainWindow::angularMinChanged(double value)
             {
                 m_angularMin = value;
                 if (m_angularAxisMode != AxisModeDateTime) {
                     m_angularAxis->setMin(m_angularMin);
                 } else {
                     QDateTime dateTime;
                     dateTime.setMSecsSinceEpoch(qint64(m_angularMin));
                     m_angularAxis->setMin(dateTime);
                 }
             }
             void MainWindow::angularMaxChanged(double value)
             {
                 m_angularMax = value;
                 if (m_angularAxisMode != AxisModeDateTime) {
                     m_angularAxis->setMax(m_angularMax);
                 } else {
                     QDateTime dateTime;
                     dateTime.setMSecsSinceEpoch(qint64(m_angularMax));
                     m_angularAxis->setMax(dateTime);
                 }
             }
             void MainWindow::radialMinChanged(double value)
             {
                 m_radialMin = value;
                 if (m_radialAxisMode != AxisModeDateTime) {
                     m_radialAxis->setMin(m_radialMin);
                 } else {
                     QDateTime dateTime;
                     dateTime.setMSecsSinceEpoch(qint64(m_radialMin));
                     m_radialAxis->setMin(dateTime);
                 }
             }
             void MainWindow::radialMaxChanged(double value)
             {
                 m_radialMax = value;
                 if (m_radialAxisMode != AxisModeDateTime) {
                     m_radialAxis->setMax(m_radialMax);
                 } else {
                     QDateTime dateTime;
                     dateTime.setMSecsSinceEpoch(qint64(m_radialMax));
                     m_radialAxis->setMax(dateTime);
                 }
             }
             void MainWindow::angularShadesIndexChanged(int index)
             {
                 delete m_angularShadesBrush;
                 delete m_angularShadesPen;
                 switch (index) {
                 case 0:
                     m_angularShadesBrush = new QBrush(Qt::NoBrush);
                     m_angularShadesPen = new QPen(Qt::NoPen);
                     m_angularShadesVisible = false;
                     break;
                 case 1:
                     m_angularShadesBrush = new QBrush(Qt::lightGray);
                     m_angularShadesPen = new QPen(Qt::NoPen);
                     m_angularShadesVisible = true;
                     break;
                 case 2:
                     m_angularShadesBrush = new QBrush(Qt::yellow);
                     m_angularShadesPen = new QPen(Qt::DotLine);
                     m_angularShadesPen->setWidth(2);
                     m_angularShadesVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_angularAxis->setShadesBrush(*m_angularShadesBrush);
                 m_angularAxis->setShadesPen(*m_angularShadesPen);
                 m_angularAxis->setShadesVisible(m_angularShadesVisible);
             }
             void MainWindow::radialShadesIndexChanged(int index)
             {
                 delete m_radialShadesBrush;
                 delete m_radialShadesPen;
                 switch (index) {
                 case 0:
                     m_radialShadesBrush = new QBrush(Qt::NoBrush);
                     m_radialShadesPen = new QPen(Qt::NoPen);
                     m_radialShadesVisible = false;
                     break;
                 case 1:
                     m_radialShadesBrush = new QBrush(Qt::green);
                     m_radialShadesPen = new QPen(Qt::NoPen);
                     m_radialShadesVisible = true;
                     break;
                 case 2:
                     m_radialShadesBrush = new QBrush(Qt::blue);
                     m_radialShadesPen = new QPen(Qt::DotLine);
                     m_radialShadesPen->setWidth(2);
                     m_radialShadesVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_radialAxis->setShadesBrush(*m_radialShadesBrush);
                 m_radialAxis->setShadesPen(*m_radialShadesPen);
                 m_radialAxis->setShadesVisible(m_radialShadesVisible);
             }
             void MainWindow::labelFormatEdited(const QString &text)
             {
                 m_labelFormat = text;
                 if (m_angularAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
                 else if (m_angularAxisMode == AxisModeLogValue)
                     static_cast<QLogValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
                 if (m_radialAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
                 else if (m_radialAxisMode == AxisModeLogValue)
                     static_cast<QLogValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
             }
             void MainWindow::labelFontChanged(const QFont &font)
             {
                 m_currentLabelFont = font;
                 m_currentLabelFont.setPixelSize(ui->labelFontSizeSpin->value());
                 m_angularAxis->setLabelsFont(m_currentLabelFont);
                 m_radialAxis->setLabelsFont(m_currentLabelFont);
             }
             void MainWindow::labelFontSizeChanged(int value)
             {
                 m_currentLabelFont = ui->labelFontComboBox->currentFont();
                 m_currentLabelFont.setPixelSize(value);
                 m_angularAxis->setLabelsFont(m_currentLabelFont);
                 m_radialAxis->setLabelsFont(m_currentLabelFont);
             }
             void MainWindow::animationIndexChanged(int index)
             {
                 switch (index) {
                 case 0:
                     m_animationOptions = QChart::NoAnimation;
                     break;
                 case 1:
                     m_animationOptions = QChart::SeriesAnimations;
                     break;
                 case 2:
                     m_animationOptions = QChart::GridAxisAnimations;
                     break;
                 case 3:
                     m_animationOptions = QChart::AllAnimations;
                     break;
                 default:
                     break;
                 }
                 m_chart->setAnimationOptions(m_animationOptions);
             }
             void MainWindow::labelsIndexChanged(int index)
             {
                 delete m_labelBrush;
                 delete m_labelPen;
                 switch (index) {
                 case 0:
                     m_labelBrush = new QBrush(Qt::NoBrush);
                     m_labelPen = new QPen(Qt::NoPen);
                     m_labelsVisible = false;
                     break;
                 case 1:
                     m_labelBrush = new QBrush(Qt::black);
                     m_labelPen = new QPen(Qt::NoPen);
                     m_labelsVisible = true;
                     break;
                 case 2:
                     m_labelBrush = new QBrush(Qt::white);
                     m_labelPen = new QPen(Qt::blue);
                     m_labelsVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_radialAxis->setLabelsBrush(*m_labelBrush);
                 m_radialAxis->setLabelsPen(*m_labelPen);
                 m_radialAxis->setLabelsVisible(m_labelsVisible);
                 m_angularAxis->setLabelsBrush(*m_labelBrush);
                 m_angularAxis->setLabelsPen(*m_labelPen);
                 m_angularAxis->setLabelsVisible(m_labelsVisible);
             }
             void MainWindow::titleIndexChanged(int index)
             {
                 delete m_titleBrush;
                 delete m_titlePen;
                 switch (index) {
                 case 0:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     m_titlePen = new QPen(Qt::NoPen);
                     m_titleVisible = false;
                     m_angularTitle = QString();
                     m_radialTitle = QString();
                     break;
                 case 1:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     m_titlePen = new QPen(Qt::NoPen);
                     m_titleVisible = true;
                     m_angularTitle = QString();
                     m_radialTitle = QString();
                     break;
                 case 2:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     m_titlePen = new QPen(Qt::NoPen);
                     m_titleVisible = false;
                     m_angularTitle = QString("Invisible Ang. Title!");
                     m_radialTitle = QString("Invisible Rad. Title!");
                     break;
                 case 3:
                     m_titleBrush = new QBrush(Qt::black);
                     m_titlePen = new QPen(Qt::NoPen);
                     m_titleVisible = true;
                     m_angularTitle = QString("Angular Title");
                     m_radialTitle = QString("Radial Title");
                     break;
                 case 4:
                     m_titleBrush = new QBrush(Qt::white);
                     m_titlePen = new QPen(Qt::blue);
                     m_titleVisible = true;
                     m_angularTitle = QString("Angular Blue Title");
                     m_radialTitle = QString("Radial Blue Title");
                     break;
                 default:
                     break;
                 }
                 m_radialAxis->setTitleBrush(*m_titleBrush);
                 m_radialAxis->setTitlePen(*m_titlePen);
                 m_radialAxis->setTitleVisible(m_titleVisible);
                 m_radialAxis->setTitleText(m_radialTitle);
                 m_angularAxis->setTitleBrush(*m_titleBrush);
                 m_angularAxis->setTitlePen(*m_titlePen);
                 m_angularAxis->setTitleVisible(m_titleVisible);
                 m_angularAxis->setTitleText(m_angularTitle);
             }
             void MainWindow::titleFontChanged(const QFont &font)
             {
                 m_currentTitleFont = font;
                 m_currentTitleFont.setPixelSize(ui->titleFontSizeSpin->value());
                 m_angularAxis->setTitleFont(m_currentTitleFont);
                 m_radialAxis->setTitleFont(m_currentTitleFont);
             }
             void MainWindow::titleFontSizeChanged(int value)
             {
                 m_currentTitleFont = ui->titleFontComboBox->currentFont();
                 m_currentTitleFont.setPixelSize(value);
                 m_angularAxis->setTitleFont(m_currentTitleFont);
                 m_radialAxis->setTitleFont(m_currentTitleFont);
             }
             void MainWindow::gridIndexChanged(int index)
             {
                 delete m_gridPen;
                 switch (index) {
                 case 0:
                     m_gridPen = new QPen(Qt::NoPen);
                     m_gridVisible = false;
                     break;
                 case 1:
                     m_gridPen = new QPen(Qt::black);
                     m_gridVisible = true;
                     break;
                 case 2:
                     m_gridPen = new QPen(Qt::red);
                     m_gridPen->setStyle(Qt::DashDotLine);
                     m_gridPen->setWidth(3);
                     m_gridVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_angularAxis->setGridLinePen(*m_gridPen);
                 m_angularAxis->setGridLineVisible(m_gridVisible);
                 m_radialAxis->setGridLinePen(*m_gridPen);
                 m_radialAxis->setGridLineVisible(m_gridVisible);
             }
             void MainWindow::arrowIndexChanged(int index)
             {
                 delete m_arrowPen;
                 switch (index) {
                 case 0:
                     m_arrowPen = new QPen(Qt::NoPen);
                     m_arrowVisible = false;
                     break;
                 case 1:
                     m_arrowPen = new QPen(Qt::black);
                     m_arrowVisible = true;
                     break;
                 case 2:
                     m_arrowPen = new QPen(Qt::red);
                     m_arrowPen->setStyle(Qt::DashDotLine);
                     m_arrowPen->setWidth(3);
                     m_arrowVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_angularAxis->setLinePen(*m_arrowPen);
                 m_angularAxis->setLineVisible(m_arrowVisible);
                 m_radialAxis->setLinePen(*m_arrowPen);
                 m_radialAxis->setLineVisible(m_arrowVisible);
             }
             void MainWindow::angularRangeChanged(qreal min, qreal max)
             {
                 if (!qFuzzyCompare(ui->angularMinSpin->value(), min))
                     ui->angularMinSpin->setValue(min);
                 if (!qFuzzyCompare(ui->angularMaxSpin->value(), max))
                     ui->angularMaxSpin->setValue(max);
             }
             void MainWindow::radialRangeChanged(qreal min, qreal max)
             {
                 if (!qFuzzyCompare(ui->radialMinSpin->value(), min))
                     ui->radialMinSpin->setValue(min);
                 if (!qFuzzyCompare(ui->radialMaxSpin->value(), max))
                     ui->radialMaxSpin->setValue(max);
             }
             void MainWindow::angularAxisIndexChanged(int index)
             {
                 switch (index) {
                 case 0:
                     setAngularAxis(AxisModeNone);
                     break;
                 case 1:
                     setAngularAxis(AxisModeValue);
                     break;
                 case 2:
                     setAngularAxis(AxisModeLogValue);
                     break;
                 case 3:
                     setAngularAxis(AxisModeDateTime);
                     break;
                 case 4:
                     setAngularAxis(AxisModeCategory);
                     break;
                 default:
                     qWarning("Invalid Index!");
                 }
             }
             void MainWindow::radialAxisIndexChanged(int index)
             {
                 switch (index) {
                 case 0:
                     setRadialAxis(AxisModeNone);
                     break;
                 case 1:
                     setRadialAxis(AxisModeValue);
                     break;
                 case 2:
                     setRadialAxis(AxisModeLogValue);
                     break;
                 case 3:
                     setRadialAxis(AxisModeDateTime);
                     break;
                 case 4:
                     setRadialAxis(AxisModeCategory);
                     break;
                 default:
                     qWarning("Invalid Index!");
                 }
             }
             void MainWindow::logBaseChanged(double value)
             {
                 m_base = value;
                 if (m_angularAxisMode == AxisModeLogValue)
                     static_cast<QLogValueAxis *>(m_angularAxis)->setBase(m_base);
                 if (m_radialAxisMode == AxisModeLogValue)
                     static_cast<QLogValueAxis *>(m_radialAxis)->setBase(m_base);
             }
             void MainWindow::niceNumbersChecked()
             {
                 if (ui->niceNumbersCheckBox->isChecked())
                     applyRanges();
             }
             void MainWindow::dateFormatEdited(const QString &text)
             {
                 m_dateFormat = text;
                 if (m_angularAxisMode == AxisModeDateTime)
                     static_cast<QDateTimeAxis *>(m_angularAxis)->setFormat(m_dateFormat);
                 if (m_radialAxisMode == AxisModeDateTime)
                     static_cast<QDateTimeAxis *>(m_radialAxis)->setFormat(m_dateFormat);
             }
             void MainWindow::moreCategoriesChecked()
             {
                 applyCategories();
                 m_moreCategories = ui->moreCategoriesCheckBox->isChecked();
             }
             void MainWindow::series1CheckBoxChecked()
             {
                 if (ui->series1checkBox->isChecked())
                     m_series1->setVisible(true);
                 else
                     m_series1->setVisible(false);
             }
             void MainWindow::series2CheckBoxChecked()
             {
                 if (ui->series2checkBox->isChecked())
                     m_series2->setVisible(true);
                 else
                     m_series2->setVisible(false);
             }
             void MainWindow::series3CheckBoxChecked()
             {
                 if (ui->series3checkBox->isChecked())
                     m_series3->setVisible(true);
                 else
                     m_series3->setVisible(false);
             }
             void MainWindow::series4CheckBoxChecked()
             {
                 if (ui->series4checkBox->isChecked())
                     m_series4->setVisible(true);
                 else
                     m_series4->setVisible(false);
             }
             void MainWindow::series5CheckBoxChecked()
             {
                 if (ui->series5checkBox->isChecked())
                     m_series5->setVisible(true);
                 else
                     m_series5->setVisible(false);
             }
             void MainWindow::series6CheckBoxChecked()
             {
                 if (ui->series6checkBox->isChecked())
                     m_series6->setVisible(true);
                 else
                     m_series6->setVisible(false);
             }
             void MainWindow::series7CheckBoxChecked()
             {
                 if (ui->series7checkBox->isChecked())
                     m_series7->setVisible(true);
                 else
                     m_series7->setVisible(false);
             }
             void MainWindow::themeIndexChanged(int index)
             {
                 m_chart->setTheme(QChart::ChartTheme(index));
             }
             void MainWindow::seriesHovered(QPointF point, bool state)
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *>(sender());
                 if (series) {
                     if (state) {
                         QString str("'%3' - %1 x %2");
                         ui->hoverLabel->setText(str.arg(point.x()).arg(point.y()).arg(series->name()));
                     } else {
                         ui->hoverLabel->setText("No hover");
                     }
                 } else {
                     qDebug() << "seriesHovered - invalid sender!";
                 }
             }
             void MainWindow::seriesClicked(const QPointF &point)
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *>(sender());
                 if (series) {
                     QString str("'%3' clicked at: %1 x %2");
                     m_angularTitle = str.arg(point.x()).arg(point.y()).arg(series->name());
                     m_angularAxis->setTitleText(m_angularTitle);
                 } else {
                     qDebug() << "seriesClicked -  invalid sender!";
                 }
             }
+            void MainWindow::backgroundIndexChanged(int index)
+            {
+                delete m_backgroundBrush;
+                delete m_backgroundPen;
+                switch (index) {
+                case 0:
+                    m_backgroundBrush = new QBrush(Qt::white);
+                    m_backgroundPen = new QPen(Qt::NoPen);
+                    break;
+                case 1:
+                    m_backgroundBrush = new QBrush(Qt::blue);
+                    m_backgroundPen = new QPen(Qt::NoPen);
+                    break;
+                case 2:
+                    m_backgroundBrush = new QBrush(Qt::yellow);
+                    m_backgroundPen = new QPen(Qt::black, 2);
+                    break;
+                default:
+                    break;
+                }
+                m_chart->setBackgroundBrush(*m_backgroundBrush);
+                m_chart->setBackgroundPen(*m_backgroundPen);
+            }
+            void MainWindow::plotAreaIndexChanged(int index)
+            {
+                delete m_plotAreaBackgroundBrush;
+                delete m_plotAreaBackgroundPen;
+                switch (index) {
+                case 0:
+                    m_plotAreaBackgroundBrush = new QBrush(Qt::green);
+                    m_plotAreaBackgroundPen = new QPen(Qt::green);
+                    m_chart->setPlotAreaBackgroundVisible(false);
+                    break;
+                case 1:
+                    m_plotAreaBackgroundBrush = new QBrush(Qt::magenta);
+                    m_plotAreaBackgroundPen = new QPen(Qt::NoPen);
+                    m_chart->setPlotAreaBackgroundVisible(true);
+                    break;
+                case 2:
+                    m_plotAreaBackgroundBrush = new QBrush(Qt::lightGray);
+                    m_plotAreaBackgroundPen = new QPen(Qt::red, 6);
+                    m_chart->setPlotAreaBackgroundVisible(true);
+                    break;
+                default:
+                    break;
+                }
+                m_chart->setPlotAreaBackgroundBrush(*m_plotAreaBackgroundBrush);
+                m_chart->setPlotAreaBackgroundPen(*m_plotAreaBackgroundPen);
+            }
             void MainWindow::applyCategories()
             {
                 // Basic layout is three categories, extended has five
                 if (m_angularAxisMode == AxisModeCategory) {
                     QCategoryAxis *angCatAxis = static_cast<QCategoryAxis *>(m_angularAxis);
                     if (angCatAxis->count() == 0) {
                         angCatAxis->setStartValue(4000);
                         angCatAxis->append("Category A", 7000);
                         angCatAxis->append("Category B", 12000);
                         angCatAxis->append("Category C", 17000);
                     }
                     if (angCatAxis->count() == 3 && ui->moreCategoriesCheckBox->isChecked()) {
                         angCatAxis->setStartValue(1000);
                         angCatAxis->replaceLabel("Category A", "Cat A");
                         angCatAxis->replaceLabel("Category B", "Cat B");
                         angCatAxis->replaceLabel("Category C", "Cat C");
                         angCatAxis->append("Cat D", 22000);
                         angCatAxis->append("Cat E", 28000);
                     } else if (angCatAxis->count() == 5 && !ui->moreCategoriesCheckBox->isChecked()) {
                         angCatAxis->setStartValue(4000);
                         angCatAxis->replaceLabel("Cat A", "Category A");
                         angCatAxis->replaceLabel("Cat B", "Category B");
                         angCatAxis->replaceLabel("Cat C", "Category C");
                         angCatAxis->remove("Cat D");
                         angCatAxis->remove("Cat E");
                     }
                 }
                 if (m_radialAxisMode == AxisModeCategory) {
                     QCategoryAxis *radCatAxis = static_cast<QCategoryAxis *>(m_radialAxis);
                     if (radCatAxis->count() == 0) {
                         radCatAxis->setStartValue(2000);
                         radCatAxis->append("Category 1", 4000);
                         radCatAxis->append("Category 2", 9000);
                         radCatAxis->append("Category 3", 14000);
                     }
                     if (radCatAxis->count() == 3 && ui->moreCategoriesCheckBox->isChecked()) {
                         radCatAxis->setStartValue(1000);
                         radCatAxis->replaceLabel("Category 1", "Cat 1");
                         radCatAxis->replaceLabel("Category 2", "Cat 2");
                         radCatAxis->replaceLabel("Category 3", "Cat 3");
                         radCatAxis->append("Cat 4", 16500);
                         radCatAxis->append("Cat 5", 19000);
                     } else if (radCatAxis->count() == 5 && !ui->moreCategoriesCheckBox->isChecked()) {
                         radCatAxis->setStartValue(2000);
                         radCatAxis->replaceLabel("Cat 1", "Category 1");
                         radCatAxis->replaceLabel("Cat 2", "Category 2");
                         radCatAxis->replaceLabel("Cat 3", "Category 3");
                         radCatAxis->remove("Cat 4");
                         radCatAxis->remove("Cat 5");
                     }
                 }
             }

tests/polarcharttest/mainwindow.h +6 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$
             **
             ****************************************************************************/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QPolarChart>
             #include <QMainWindow>
             #include <QFont>
             #include <QChart>
             #include <QScatterSeries>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QAreaSeries>
             namespace Ui {
             class MainWindow;
             }
             QTCOMMERCIALCHART_USE_NAMESPACE
             class QBrush;
             class QPen;
             class MainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 explicit MainWindow(QWidget *parent = 0);
                 ~MainWindow();
             public slots:
                 void angularTicksChanged(int value);
                 void radialTicksChanged(int value);
                 void anglesChanged(int value);
                 void angularMinChanged(double value);
                 void angularMaxChanged(double value);
                 void radialMinChanged(double value);
                 void radialMaxChanged(double value);
                 void angularShadesIndexChanged(int index);
                 void radialShadesIndexChanged(int index);
                 void labelFormatEdited(const QString &text);
                 void labelFontChanged(const QFont &font);
                 void labelFontSizeChanged(int value);
                 void animationIndexChanged(int index);
                 void labelsIndexChanged(int index);
                 void titleIndexChanged(int index);
                 void titleFontChanged(const QFont &font);
                 void titleFontSizeChanged(int value);
                 void gridIndexChanged(int index);
                 void arrowIndexChanged(int index);
                 void angularRangeChanged(qreal min, qreal max);
                 void radialRangeChanged(qreal min, qreal max);
                 void angularAxisIndexChanged(int index);
                 void radialAxisIndexChanged(int index);
                 void logBaseChanged(double value);
                 void niceNumbersChecked();
                 void dateFormatEdited(const QString &text);
                 void moreCategoriesChecked();
                 void series1CheckBoxChecked();
                 void series2CheckBoxChecked();
                 void series3CheckBoxChecked();
                 void series4CheckBoxChecked();
                 void series5CheckBoxChecked();
                 void series6CheckBoxChecked();
                 void series7CheckBoxChecked();
                 void themeIndexChanged(int index);
                 void seriesHovered(QPointF point, bool state);
                 void seriesClicked(const QPointF &point);
+                void backgroundIndexChanged(int index);
+                void plotAreaIndexChanged(int index);
             private:
                 enum AxisMode {
                     AxisModeNone,
                     AxisModeValue,
                     AxisModeLogValue,
                     AxisModeDateTime,
                     AxisModeCategory
                 };
                 void initXYValueChart();
                 void setAngularAxis(AxisMode mode);
                 void setRadialAxis(AxisMode mode);
                 void applyRanges();
                 void applyCategories();
                 Ui::MainWindow *ui;
                 int m_angularTickCount;
                 int m_radialTickCount;
                 qreal m_labelsAngle;
                 qreal m_angularMin;
                 qreal m_angularMax;
                 qreal m_radialMin;
                 qreal m_radialMax;
                 bool m_angularShadesVisible;
                 bool m_radialShadesVisible;
                 bool m_labelsVisible;
                 bool m_titleVisible;
                 bool m_gridVisible;
                 bool m_arrowVisible;
                 QBrush *m_angularShadesBrush;
                 QBrush *m_radialShadesBrush;
                 QBrush *m_labelBrush;
                 QBrush *m_titleBrush;
+                QBrush *m_backgroundBrush;
+                QBrush *m_plotAreaBackgroundBrush;
                 QPen *m_angularShadesPen;
                 QPen *m_radialShadesPen;
                 QPen *m_labelPen;
                 QPen *m_titlePen;
                 QPen *m_gridPen;
                 QPen *m_arrowPen;
+                QPen *m_backgroundPen;
+                QPen *m_plotAreaBackgroundPen;
                 QString m_labelFormat;
                 QFont m_currentLabelFont;
                 QFont m_currentTitleFont;
                 QChart::AnimationOptions m_animationOptions;
                 QString m_angularTitle;
                 QString m_radialTitle;
                 qreal m_base;
                 QString m_dateFormat;
                 QPolarChart *m_chart;
                 QAbstractAxis *m_angularAxis;
                 QAbstractAxis *m_radialAxis;
                 AxisMode m_angularAxisMode;
                 AxisMode m_radialAxisMode;
                 bool m_moreCategories;
                 QScatterSeries *m_series1;
                 QLineSeries *m_series2;
                 QLineSeries *m_series3;
                 QLineSeries *m_series4;
                 QAreaSeries *m_series5;
                 QSplineSeries *m_series6;
                 QScatterSeries *m_series7;
             };
             #endif // MAINWINDOW_H

tests/polarcharttest/mainwindow.ui +71 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>1207</width>
+                <width>1193</width>
-                <height>905</height>
+                <height>956</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>MainWindow</string>
               </property>
               <widget class="QWidget" name="centralWidget">
                <layout class="QHBoxLayout" name="horizontalLayout">
                 <item>
                  <widget class="ChartView" name="chartView"/>
                 </item>
                 <item>
                  <widget class="QGroupBox" name="settingsBox">
                   <property name="sizePolicy">
                    <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                     <horstretch>0</horstretch>
                     <verstretch>0</verstretch>
                    </sizepolicy>
                   </property>
                   <property name="minimumSize">
                    <size>
                     <width>200</width>
                     <height>0</height>
                    </size>
                   </property>
                   <property name="title">
                    <string>Settings</string>
                   </property>
                   <widget class="QSpinBox" name="radialTicksSpin">
                    <property name="geometry">
                     <rect>
                      <x>110</x>
                      <y>90</y>
                      <width>71</width>
                      <height>22</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>90</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Radial Tick count</string>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_2">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>120</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Angular Tick count</string>
                    </property>
                   </widget>
                   <widget class="QSpinBox" name="angularTicksSpin">
                    <property name="geometry">
                     <rect>
                      <x>110</x>
                      <y>120</y>
                      <width>71</width>
                      <height>22</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QSpinBox" name="anglesSpin">
                    <property name="geometry">
                     <rect>
                      <x>110</x>
                      <y>150</y>
                      <width>71</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="minimum">
                     <number>-9999</number>
                    </property>
                    <property name="maximum">
                     <number>9999</number>
                    </property>
                    <property name="singleStep">
                     <number>5</number>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_3">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>150</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Label angles</string>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_4">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>180</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Angular min</string>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_5">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>210</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Angular max</string>
                    </property>
                   </widget>
                   <widget class="QDoubleSpinBox" name="angularMinSpin">
                    <property name="geometry">
                     <rect>
                      <x>90</x>
                      <y>180</y>
                      <width>91</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="decimals">
                     <number>5</number>
                    </property>
                    <property name="minimum">
                     <double>-999999999.000000000000000</double>
                    </property>
                    <property name="maximum">
                     <double>999999999.000000000000000</double>
                    </property>
                    <property name="singleStep">
                     <double>10.000000000000000</double>
                    </property>
                   </widget>
                   <widget class="QDoubleSpinBox" name="angularMaxSpin">
                    <property name="geometry">
                     <rect>
                      <x>90</x>
                      <y>210</y>
                      <width>91</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="decimals">
                     <number>5</number>
                    </property>
                    <property name="minimum">
                     <double>-999999999.000000000000000</double>
                    </property>
                    <property name="maximum">
                     <double>999999999.000000000000000</double>
                    </property>
                    <property name="singleStep">
                     <double>10.000000000000000</double>
                    </property>
                   </widget>
                   <widget class="QDoubleSpinBox" name="radialMaxSpin">
                    <property name="geometry">
                     <rect>
                      <x>90</x>
                      <y>270</y>
                      <width>91</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="decimals">
                     <number>5</number>
                    </property>
                    <property name="minimum">
                     <double>-999999999.000000000000000</double>
                    </property>
                    <property name="maximum">
                     <double>999999999.000000000000000</double>
                    </property>
                    <property name="singleStep">
                     <double>10.000000000000000</double>
                    </property>
                   </widget>
                   <widget class="QDoubleSpinBox" name="radialMinSpin">
                    <property name="geometry">
                     <rect>
                      <x>90</x>
                      <y>240</y>
                      <width>91</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="decimals">
                     <number>5</number>
                    </property>
                    <property name="minimum">
                     <double>-999999999.000000000000000</double>
                    </property>
                    <property name="maximum">
                     <double>999999999.000000000000000</double>
                    </property>
                    <property name="singleStep">
                     <double>10.000000000000000</double>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_11">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>270</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Radial max</string>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_12">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>240</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Radial min</string>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="angularShadesComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>300</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No angular shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Gray angular shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Yellow ang. shades + custom pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="radialShadesComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>330</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No radial shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Green radial shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Blue rad. shades + custom pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QLabel" name="label_13">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>360</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Label format</string>
                    </property>
                   </widget>
                   <widget class="QLineEdit" name="labelFormatEdit">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>360</y>
                      <width>81</width>
                      <height>20</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_14">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>390</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Label font size</string>
                    </property>
                   </widget>
                   <widget class="QFontComboBox" name="labelFontComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>420</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QSpinBox" name="labelFontSizeSpin">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>390</y>
                      <width>81</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="minimum">
                     <number>-100000</number>
                    </property>
                    <property name="maximum">
                     <number>100000</number>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="animationsComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>480</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No animations</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Series animation</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Grid animation</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>All animations</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="labelComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>450</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No labels</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black label</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>White label + blue pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QSpinBox" name="titleFontSizeSpin">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>510</y>
                      <width>81</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="minimum">
                     <number>-100000</number>
                    </property>
                    <property name="maximum">
                     <number>100000</number>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="titleComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>570</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>3</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible empty title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Visible empty title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Invisible title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>White title + blue pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QFontComboBox" name="titleFontComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>540</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_15">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>510</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Title font size</string>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="gridComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>600</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Custom grid pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="arrowComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>630</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible arrow</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black arrow</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Custom arrow pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="angularAxisComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>20</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No Angular Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Value Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Log Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular DateTime Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Category Axis</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="radialAxisComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>50</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No Radial Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Value Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Log Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial DateTime Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Category Axis</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QLabel" name="label_16">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>660</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Log Base</string>
                    </property>
                   </widget>
                   <widget class="QDoubleSpinBox" name="logBaseSpin">
                    <property name="geometry">
                     <rect>
                      <x>90</x>
                      <y>660</y>
                      <width>91</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="decimals">
                     <number>5</number>
                    </property>
                    <property name="minimum">
                     <double>-999999999.000000000000000</double>
                    </property>
                    <property name="maximum">
                     <double>999999999.000000000000000</double>
                    </property>
                    <property name="value">
                     <double>8.000000000000000</double>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="niceNumbersCheckBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>690</y>
                      <width>91</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Nice Numbers</string>
                    </property>
                   </widget>
                   <widget class="QLineEdit" name="dateFormatEdit">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>710</y>
                      <width>81</width>
                      <height>20</height>
                     </rect>
                    </property>
                   </widget>
                   <widget class="QLabel" name="label_17">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>710</y>
                      <width>101</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>DateTime format</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="moreCategoriesCheckBox">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>690</y>
                      <width>141</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>More Categories</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series1checkBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>730</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>1</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series2checkBox">
                    <property name="geometry">
                     <rect>
                      <x>40</x>
                      <y>730</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>2</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series3checkBox">
                    <property name="geometry">
                     <rect>
                      <x>70</x>
                      <y>730</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>3</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series4checkBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>750</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>4</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series5checkBox">
                    <property name="geometry">
                     <rect>
                      <x>40</x>
                      <y>750</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>5</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series6checkBox">
                    <property name="geometry">
                     <rect>
                      <x>70</x>
                      <y>750</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>6</string>
                    </property>
                   </widget>
                   <widget class="QCheckBox" name="series7checkBox">
                    <property name="geometry">
                     <rect>
                      <x>100</x>
                      <y>740</y>
                      <width>31</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>7</string>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="themeComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>770</y>
                      <width>171</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>0</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Theme: Light</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Cerulean</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Dark</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Brown Sand</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Ncs</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: High Contrast</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Icy</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QLabel" name="hoverLabel">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>800</y>
                      <width>171</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Hover coordinates here!</string>
                    </property>
                   </widget>
+                  <widget class="QComboBox" name="backgroundComboBox">
+                   <property name="geometry">
+                    <rect>
+                     <x>10</x>
+                     <y>820</y>
+                     <width>171</width>
+                     <height>22</height>
+                    </rect>
+                   </property>
+                   <property name="sizePolicy">
+                    <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+                     <horstretch>0</horstretch>
+                     <verstretch>0</verstretch>
+                    </sizepolicy>
+                   </property>
+                   <property name="currentIndex">
+                    <number>0</number>
+                   </property>
+                   <item>
+                    <property name="text">
+                     <string>Background: White</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>Background: Blue</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>Background:  Yellow + Black Border</string>
+                    </property>
+                   </item>
+                  </widget>
+                  <widget class="QComboBox" name="plotAreaComboBox">
+                   <property name="geometry">
+                    <rect>
+                     <x>10</x>
+                     <y>850</y>
+                     <width>171</width>
+                     <height>22</height>
+                    </rect>
+                   </property>
+                   <property name="sizePolicy">
+                    <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+                     <horstretch>0</horstretch>
+                     <verstretch>0</verstretch>
+                    </sizepolicy>
+                   </property>
+                   <property name="currentIndex">
+                    <number>0</number>
+                   </property>
+                   <item>
+                    <property name="text">
+                     <string>PlotArea: Transparent</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>PlotArea: Magenta</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>PlotArea: Gray + Red Border</string>
+                    </property>
+                   </item>
+                  </widget>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
-                 <width>1207</width>
+                 <width>1193</width>
                  <height>21</height>
                 </rect>
                </property>
               </widget>
               <widget class="QToolBar" name="mainToolBar">
                <attribute name="toolBarArea">
                 <enum>TopToolBarArea</enum>
                </attribute>
                <attribute name="toolBarBreak">
                 <bool>false</bool>
                </attribute>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>ChartView</class>
                <extends>QGraphicsView</extends>
                <header>chartview.h</header>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

tests/qmlchartproperties/qml/qmlchartproperties/Chart.qml +2 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
-            import QtCommercial.Chart 1.2
+            import QtCommercial.Chart 1.3
             ChartView {
                 id: chartView
                 title: "Chart Title"
                 anchors.fill: parent
                 property variant chart: chartView
                 LineSeries {
                     name: "line"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     XYPoint { x: 1.9; y: 3.3 }
                     XYPoint { x: 2.1; y: 2.1 }
                     XYPoint { x: 2.9; y: 4.9 }
                     XYPoint { x: 3.4; y: 3.0 }
                     XYPoint { x: 4.1; y: 3.3 }
                 }
                 onVisibleChanged:                  console.log("chart.onVisibleChanged: " + visible);
                 onTitleColorChanged:               console.log("chart.onTitleColorChanged: " + color);
                 onBackgroundColorChanged:          console.log("chart.onBackgroundColorChanged: " + chart.backgroundColor);
                 onDropShadowEnabledChanged:        console.log("chart.onDropShadowEnabledChanged: " + enabled);
                 onSeriesAdded:                     console.log("chart.onSeriesAdded: " + series.name);
                 onSeriesRemoved:                   console.log("chart.onSeriesRemoved: " + series.name);
+                onPlotAreaColorChanged:            console.log("chart.plotAreaColorChanged: " + chart.plotAreaColor);
                 legend.onVisibleChanged:           console.log("legend.onVisibleChanged: " + chart.legend.visible);
                 legend.onBackgroundVisibleChanged: console.log("legend.onBackgroundVisibleChanged: " + visible);
                 legend.onColorChanged:             console.log("legend.onColorChanged: " + color);
                 legend.onBorderColorChanged:       console.log("legend.onBorderColorChanged: " + color);
                 legend.onLabelColorChanged:        console.log("legend.onLabelColorChanged: " + color);
                 margins.onTopChanged:       console.log("chart.margins.onTopChanged: " + top );
                 margins.onBottomChanged:    console.log("chart.margins.onBottomChanged: " + bottom);
                 margins.onLeftChanged:      console.log("chart.margins.onLeftChanged: " + left);
                 margins.onRightChanged:     console.log("chart.margins.onRightChanged: " + right);
                 onPlotAreaChanged: {
                     console.log("chart.onPlotAreaChanged, width: " + chartView.plotArea.width
                                                                    + " height: " + chartView.plotArea.height
                                                                    + " y: " + chartView.plotArea.y
                                                                    + " x: " + chartView.plotArea.x);
                     marginVisualizer.opacity = 1.0;
                 }
                 ValueAxis{
                     onColorChanged:               console.log("axisX.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisX.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisX.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisX.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisX.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:       console.log("axisX.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisX.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisX.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisX.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisX.onMaxChanged: " + max);
                 }
                 ValueAxis{
                     onColorChanged:               console.log("axisY.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisY.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisY.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisY.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisY.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:       console.log("axisY.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisY.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisY.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisY.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisY.onMaxChanged: " + max);
                 }
                 Rectangle {
                     id: marginVisualizer
                     color: "transparent"
                     border.color: "red"
                     anchors.fill: parent
                     anchors.topMargin: chartView.minimumMargins.top
                     anchors.bottomMargin: chartView.minimumMargins.bottom
                     anchors.leftMargin: chartView.minimumMargins.left
                     anchors.rightMargin: chartView.minimumMargins.right
                     opacity: 0.0
                     onOpacityChanged: if (opacity > 0.9) opacity = 0.0;
                     Behavior on opacity {
                         NumberAnimation { duration: 800 }
                     }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ChartEditorProperties.qml +4 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 anchors.fill: parent
                 property variant chart
                 flow: Flow.TopToBottom
                 spacing: 5
                 Button {
                     text: "visible"
                     onClicked: chart.visible = !chart.visible;
                 }
                 Button {
                     text: "theme +"
                     onClicked: chart.theme++;
                 }
                 Button {
                     text: "theme -"
                     onClicked: chart.theme--;
                 }
                 Button {
                     text: "animation opt +"
                     onClicked: chart.animationOptions++;
                 }
                 Button {
                     text: "animation opt -"
                     onClicked: chart.animationOptions--;
                 }
                 Button {
                     text: "background color"
                     onClicked: chart.backgroundColor = main.nextColor();
                 }
                 Button {
+                    text: "plot area color"
+                    onClicked: chart.plotAreaColor = main.nextColor();
+                }
+                Button {
                     text: "drop shadow enabled"
                     onClicked: chart.dropShadowEnabled = !chart.dropShadowEnabled;
                 }
                 Button {
                     text: "zoom +"
                     onClicked: chart.zoom(2);
                 }
                 Button {
                     text: "zoom -"
                     onClicked: chart.zoom(0.5);
                 }
                 Button {
                     text: "scroll left"
                     onClicked: chart.scrollLeft(10);
                 }
                 Button {
                     text: "scroll right"
                     onClicked: chart.scrollRight(10);
                 }
                 Button {
                     text: "scroll up"
                     onClicked: chart.scrollUp(10);
                 }
                 Button {
                     text: "scroll down"
                     onClicked: chart.scrollDown(10);
                 }
                 Button {
                     text: "title color"
                     onClicked: chart.titleColor = main.nextColor();
                 }
                 Button {
                     text: "top margin +"
                     onClicked: chart.margins.top += 5;
                 }
                 Button {
                     text: "top margin -"
                     onClicked: chart.margins.top -= 5;
                 }
                 Button {
                     text: "bottom margin +"
                     onClicked: chart.margins.bottom += 5;
                 }
                 Button {
                     text: "bottom margin -"
                     onClicked: chart.margins.bottom -= 5;
                 }
                 Button {
                     text: "left margin +"
                     onClicked: chart.margins.left += 5;
                 }
                 Button {
                     text: "left margin -"
                     onClicked: chart.margins.left -= 5;
                 }
                 Button {
                     text: "right margin +"
                     onClicked: chart.margins.right += 5;
                 }
                 Button {
                     text: "right margin -"
                     onClicked: chart.margins.right -= 5;
                 }
             }

tests/quick2chartproperties/qml/quick2chartproperties/Chart.qml +2 -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$
             **
             ****************************************************************************/
             import QtQuick 2.0
-            import QtCommercial.Chart 1.2
+            import QtCommercial.Chart 1.3
             ChartView {
                 id: chartView
                 title: "Chart Title"
                 anchors.fill: parent
                 property variant chart: chartView
                 LineSeries {
                     name: "line"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     XYPoint { x: 1.9; y: 3.3 }
                     XYPoint { x: 2.1; y: 2.1 }
                     XYPoint { x: 2.9; y: 4.9 }
                     XYPoint { x: 3.4; y: 3.0 }
                     XYPoint { x: 4.1; y: 3.3 }
                 }
                 onVisibleChanged:                  console.log("chart.onVisibleChanged: " + visible);
                 onTitleColorChanged:               console.log("chart.onTitleColorChanged: " + color);
                 onBackgroundColorChanged:          console.log("chart.onBackgroundColorChanged: " + chart.backgroundColor);
                 onDropShadowEnabledChanged:        console.log("chart.onDropShadowEnabledChanged: " + enabled);
                 onSeriesAdded:                     console.log("chart.onSeriesAdded: " + series.name);
                 onSeriesRemoved:                   console.log("chart.onSeriesRemoved: " + series.name);
+                onPlotAreaColorChanged:            console.log("chart.plotAreaColorChanged: " + chart.plotAreaColor);
                 legend.onVisibleChanged:           console.log("legend.onVisibleChanged: " + chart.legend.visible);
                 legend.onBackgroundVisibleChanged: console.log("legend.onBackgroundVisibleChanged: " + visible);
                 legend.onColorChanged:             console.log("legend.onColorChanged: " + color);
                 legend.onBorderColorChanged:       console.log("legend.onBorderColorChanged: " + color);
                 legend.onLabelColorChanged:        console.log("legend.onLabelColorChanged: " + color);
                 margins.onTopChanged:       console.log("chart.margins.onTopChanged: " + top );
                 margins.onBottomChanged:    console.log("chart.margins.onBottomChanged: " + bottom);
                 margins.onLeftChanged:      console.log("chart.margins.onLeftChanged: " + left);
                 margins.onRightChanged:     console.log("chart.margins.onRightChanged: " + right);
                 onPlotAreaChanged: {
                     console.log("chart.onPlotAreaChanged, width: " + chartView.plotArea.width
                                                                    + " height: " + chartView.plotArea.height
                                                                    + " y: " + chartView.plotArea.y
                                                                    + " x: " + chartView.plotArea.x);
                     marginVisualizer.opacity = 1.0;
                 }
                 ValueAxis{
                     onColorChanged:               console.log("axisX.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisX.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisX.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisX.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisX.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:       console.log("axisX.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisX.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisX.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisX.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisX.onMaxChanged: " + max);
                 }
                 ValueAxis{
                     onColorChanged:               console.log("axisY.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisY.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisY.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisY.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisY.onGridVisibleChanged: " + visible);
                     onShadesVisibleChanged:       console.log("axisY.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisY.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisY.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisY.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisY.onMaxChanged: " + max);
                 }
                 Rectangle {
                     id: marginVisualizer
                     color: "transparent"
                     border.color: "red"
                     anchors.fill: parent
                     anchors.topMargin: chartView.minimumMargins.top
                     anchors.bottomMargin: chartView.minimumMargins.bottom
                     anchors.leftMargin: chartView.minimumMargins.left
                     anchors.rightMargin: chartView.minimumMargins.right
                     opacity: 0.0
                     onOpacityChanged: if (opacity > 0.9) opacity = 0.0;
                     Behavior on opacity {
                         NumberAnimation { duration: 800 }
                     }
                 }
             }

tests/quick2chartproperties/qml/quick2chartproperties/ChartEditorProperties.qml +4 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$
             **
             ****************************************************************************/
             import QtQuick 2.0
             Flow {
                 anchors.fill: parent
                 property variant chart
                 flow: Flow.TopToBottom
                 spacing: 5
                 Button {
                     text: "visible"
                     onClicked: chart.visible = !chart.visible;
                 }
                 Button {
                     text: "theme +"
                     onClicked: chart.theme++;
                 }
                 Button {
                     text: "theme -"
                     onClicked: chart.theme--;
                 }
                 Button {
                     text: "animation opt +"
                     onClicked: chart.animationOptions++;
                 }
                 Button {
                     text: "animation opt -"
                     onClicked: chart.animationOptions--;
                 }
                 Button {
                     text: "background color"
                     onClicked: chart.backgroundColor = main.nextColor();
                 }
                 Button {
+                    text: "plot area color"
+                    onClicked: chart.plotAreaColor = main.nextColor();
+                }
+                Button {
                     text: "drop shadow enabled"
                     onClicked: chart.dropShadowEnabled = !chart.dropShadowEnabled;
                 }
                 Button {
                     text: "zoom +"
                     onClicked: chart.zoom(2);
                 }
                 Button {
                     text: "zoom -"
                     onClicked: chart.zoom(0.5);
                 }
                 Button {
                     text: "scroll left"
                     onClicked: chart.scrollLeft(10);
                 }
                 Button {
                     text: "scroll right"
                     onClicked: chart.scrollRight(10);
                 }
                 Button {
                     text: "scroll up"
                     onClicked: chart.scrollUp(10);
                 }
                 Button {
                     text: "scroll down"
                     onClicked: chart.scrollDown(10);
                 }
                 Button {
                     text: "title color"
                     onClicked: chart.titleColor = main.nextColor();
                 }
                 Button {
                     text: "top margin +"
                     onClicked: chart.margins.top += 5;
                 }
                 Button {
                     text: "top margin -"
                     onClicked: chart.margins.top -= 5;
                 }
                 Button {
                     text: "bottom margin +"
                     onClicked: chart.margins.bottom += 5;
                 }
                 Button {
                     text: "bottom margin -"
                     onClicked: chart.margins.bottom -= 5;
                 }
                 Button {
                     text: "left margin +"
                     onClicked: chart.margins.left += 5;
                 }
                 Button {
                     text: "left margin -"
                     onClicked: chart.margins.left -= 5;
                 }
                 Button {
                     text: "right margin +"
                     onClicked: chart.margins.right += 5;
                 }
                 Button {
                     text: "right margin -"
                     onClicked: chart.margins.right -= 5;
                 }
             }

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