HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2516:567bb8091928

Fix explicitly set default pen/brush/font getting overridden by theme...

Miikka Heikkinen -

r2516:567bb8091928

parent child

Context file:

r2516:567bb8091928

Collapse all files

src/areachart/qareaseries.cpp +5 -4

              /****************************************************************************
              **
              ** 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 "qareaseries.h"
              #include "qareaseries_p.h"
              #include "qlineseries.h"
              #include "areachartitem_p.h"
              #include "abstractdomain_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "qvalueaxis.h"
              #include "qarealegendmarker.h"
              #include "qchart_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QAreaSeries
                  \brief The QAreaSeries class is used for making area charts.
                  \mainclass
                  An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
                  is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
                  which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                  In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
                  where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                  See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                  \image examples_areachart.png
              */
              /*!
                  \qmlclass AreaSeries QAreaSeries
                  The following QML shows how to create a simple area chart:
                  \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
                  \beginfloatleft
                  \image demos_qmlchart4.png
                  \endfloat
                  \clearfloat
              */
              /*!
                 \property QAreaSeries::upperSeries
                 \brief The upper one of the two line series used to define area series boundaries.
              */
              /*!
                 \qmlproperty LineSeries AreaSeries::upperSeries
                 The upper one of the two line series used to define area series boundaries.
              */
              /*!
                  \property QAreaSeries::lowerSeries
                  The lower one of the two line series used to define are series boundaries. Note if
                  QAreaSeries was constructed without a\ lowerSeries this is null.
              */
              /*!
                  \qmlproperty LineSeries AreaSeries::lowerSeries
                  The lower one of the two line series used to define are series boundaries. Note if
                  AreaSeries was constructed without a\ lowerSeries this is null.
              */
              /*!
                  \property QAreaSeries::color
                  Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                  \sa QAreaSeries::brush()
              */
              /*!
                  \qmlproperty color AreaSeries::color
                  Fill (brush) color of the series.
              */
              /*!
                  \property QAreaSeries::borderColor
                  Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                  \sa QAreaSeries::pen()
              */
              /*!
                  \qmlproperty color AreaSeries::borderColor
                  Line (pen) color of the series.
              */
              /*!
                  \qmlproperty real AreaSeries::borderWidth
                  The width of the border line. By default the width is 2.0.
              */
              /*!
                 \fn QPen QAreaSeries::pen() const
                 \brief  Returns the pen used to draw line for this series.
                  \sa setPen()
              */
              /*!
                 \fn QPen QAreaSeries::brush() const
                 \brief  Returns the brush used to draw line for this series.
                  \sa setBrush()
              */
              /*!
                  \fn void QAreaSeries::colorChanged(QColor color)
                  \brief Signal is emitted when the fill (brush) color has changed to \a color.
              */
              /*!
                  \qmlsignal AreaSeries::onColorChanged(color color)
                  Signal is emitted when the fill (brush) color has changed to \a color.
              */
              /*!
                  \fn void QAreaSeries::borderColorChanged(QColor color)
                  \brief Signal is emitted when the line (pen) color has changed to \a color.
              */
              /*!
                  \qmlsignal AreaSeries::onBorderColorChanged(color color)
                  Signal is emitted when the line (pen) color has changed to \a color.
              */
              /*!
                  \fn void QAreaSeries::clicked(const QPointF& point)
                  \brief Signal is emitted when user clicks the \a point on area chart.
              */
              /*!
                  \qmlsignal AreaSeries::onClicked(QPointF point)
                  Signal is emitted when user clicks the \a point on area chart.
              */
              /*!
                  \fn void QAreaSeries::hovered(const QPointF &point, bool state)
                  This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                  of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                  the series.
              */
              /*!
                  \qmlsignal AreaSeries::onHovered(point point, bool state)
                  This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                  of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                  the series.
              */
              /*!
                  \fn void QAreaSeries::selected()
                  The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                  implemented by the user of QAreaSeries API.
              */
              /*!
                  \qmlsignal AreaSeries::onSelected()
                  The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                  implemented by the user of AreaSeries API.
              */
              /*!
                  \fn void QAreaSeriesPrivate::updated()
                  \brief \internal
              */
              /*!
                  Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                  upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                  When series object is added to QChartView or QChart instance ownerships is transferred.
              */
              QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                  : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries, lowerSeries, this), upperSeries)
              {
              }
              /*!
                  Constructs area series object without upper or lower series with \a parent object.
              */
              QAreaSeries::QAreaSeries(QObject *parent)
                  : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
              {
              }
              /*!
                  Destroys the object.
              */
              QAreaSeries::~QAreaSeries()
              {
                  Q_D(QAreaSeries);
                  if (d->m_chart)
                      d->m_chart->removeSeries(this);
              }
              /*!
                  Returns QChartSeries::SeriesTypeArea.
              */
              QAbstractSeries::SeriesType QAreaSeries::type() const
              {
                  return QAbstractSeries::SeriesTypeArea;
              }
              /*!
                  Sets the \a series that is to be used as the area chart upper series.
              */
              void QAreaSeries::setUpperSeries(QLineSeries *series)
              {
                  Q_D(QAreaSeries);
                  if (d->m_upperSeries != series)
                  	d->m_upperSeries = series;
              }
              QLineSeries *QAreaSeries::upperSeries() const
              {
                  Q_D(const QAreaSeries);
                  return d->m_upperSeries;
              }
              /*!
                  Sets the \a series that is to be used as the area chart lower series.
              */
              void QAreaSeries::setLowerSeries(QLineSeries *series)
              {
                  Q_D(QAreaSeries);
                  d->m_lowerSeries = series;
              }
              QLineSeries *QAreaSeries::lowerSeries() const
              {
                  Q_D(const QAreaSeries);
                  return d->m_lowerSeries;
              }
              /*!
                  Sets \a pen used for drawing area outline.
              */
              void QAreaSeries::setPen(const QPen &pen)
              {
                  Q_D(QAreaSeries);
                  if (d->m_pen != pen) {
                      d->m_pen = pen;
                      emit d->updated();
                  }
              }
              QPen  QAreaSeries::pen() const
              {
                  Q_D(const QAreaSeries);
                  return d->m_pen;
              }
              /*!
                  Sets \a brush used for filling the area.
              */
              void QAreaSeries::setBrush(const QBrush &brush)
              {
                  Q_D(QAreaSeries);
                  if (d->m_brush != brush) {
                      bool emitColorChanged = brush.color() != d->m_brush.color();
                      d->m_brush = brush;
                      emit d->updated();
                      if (emitColorChanged)
                          emit colorChanged(brush.color());
                  }
              }
              QBrush QAreaSeries::brush() const
              {
                  Q_D(const QAreaSeries);
                  return d->m_brush;
              }
              void QAreaSeries::setColor(const QColor &color)
              {
                  QBrush b = brush();
                  if (b == QBrush())
                      b.setStyle(Qt::SolidPattern);
                  b.setColor(color);
                  setBrush(b);
              }
              QColor QAreaSeries::color() const
              {
                  return brush().color();
              }
              void QAreaSeries::setBorderColor(const QColor &color)
              {
                  QPen p = pen();
                  if (p.color() != color) {
                      p.setColor(color);
                      setPen(p);
                      emit borderColorChanged(color);
                  }
              }
              QColor QAreaSeries::borderColor() const
              {
                  return pen().color();
              }
              /*!
                  Sets if data points are \a visible and should be drawn on line.
              */
              void QAreaSeries::setPointsVisible(bool visible)
              {
                  Q_D(QAreaSeries);
                  if (d->m_pointsVisible != visible) {
                      d->m_pointsVisible = visible;
                      emit d->updated();
                  }
              }
              /*!
                  Returns if the points are drawn for this series.
                  \sa setPointsVisible()
              */
              bool QAreaSeries::pointsVisible() const
              {
                  Q_D(const QAreaSeries);
                  return d->m_pointsVisible;
              }
              ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q)
                  : QAbstractSeriesPrivate(q),
+                   m_brush(QChartPrivate::defaultBrush()),
+                   m_pen(QChartPrivate::defaultPen()),
                    m_upperSeries(upperSeries),
                    m_lowerSeries(lowerSeries),
                    m_pointsVisible(false)
              {
              }
              void QAreaSeriesPrivate::initializeDomain()
              {
                  Q_Q(QAreaSeries);
                  qreal minX(domain()->minX());
                  qreal minY(domain()->minY());
                  qreal maxX(domain()->maxX());
                  qreal maxY(domain()->maxY());
                  QLineSeries *upperSeries = q->upperSeries();
                  QLineSeries *lowerSeries = q->lowerSeries();
                  const QList<QPointF>& points = upperSeries->points();
                  for (int i = 0; i < points.count(); i++) {
                      qreal x = points[i].x();
                      qreal y = points[i].y();
                      minX = qMin(minX, x);
                      minY = qMin(minY, y);
                      maxX = qMax(maxX, x);
                      maxY = qMax(maxY, y);
                  }
                  if (lowerSeries) {
                      const QList<QPointF>& points = lowerSeries->points();
                      for (int i = 0; i < points.count(); i++) {
                          qreal x = points[i].x();
                          qreal y = points[i].y();
                          minX = qMin(minX, x);
                          minY = qMin(minY, y);
                          maxX = qMax(maxX, x);
                          maxY = qMax(maxY, y);
                      }
                  }
                  domain()->setRange(minX, maxX, minY, maxY);
              }
              void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
              {
                  Q_Q(QAreaSeries);
                  AreaChartItem *area = new AreaChartItem(q,parent);
                  m_item.reset(area);
                  QAbstractSeriesPrivate::initializeGraphics(parent);
              }
              void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
              {
                  Q_Q(QAreaSeries);
                  AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                  if (options.testFlag(QChart::SeriesAnimations)) {
                      area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                      if (q->lowerSeries())
                      area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                  }else{
                      area->upperLineItem()->setAnimation(0);
                      if (q->lowerSeries())
                             area->lowerLineItem()->setAnimation(0);
                  }
                  QAbstractSeriesPrivate::initializeAnimations(options);
              }
              QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
              {
                  Q_Q(QAreaSeries);
                  QList<QLegendMarker*> list;
                  return list << new QAreaLegendMarker(q,legend);
              }
              void QAreaSeriesPrivate::initializeAxes()
              {
              }
              QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
              {
                  Q_UNUSED(orientation);
                  return QAbstractAxis::AxisTypeValue;
              }
              QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
              {
                  Q_UNUSED(orientation);
                  return 0;
              }
              void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
              {
                  Q_Q(QAreaSeries);
-                 QPen pen;
-                 QBrush brush;
                  const QList<QGradient> gradients = theme->seriesGradients();
                  const QList<QColor> colors = theme->seriesColors();
-                 if (forced || pen == m_pen) {
+                 if (forced || QChartPrivate::defaultPen() == m_pen) {
+                     QPen pen;
                      pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                      pen.setWidthF(2);
                      q->setPen(pen);
                  }
-                 if (forced || brush == m_brush) {
+                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                      QBrush brush(colors.at(index % colors.size()));
                      q->setBrush(brush);
                  }
              }
              #include "moc_qareaseries.cpp"
              #include "moc_qareaseries_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +46 -55

              /****************************************************************************
              **
              ** 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 "qabstractaxis.h"
              #include "qabstractaxis_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
+             #include "qchart_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QAbstractAxis
                  \brief The QAbstractAxis class is used for manipulating chart's axis.
                  \mainclass
                  Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                  that would result in different domains is not supported, such as specifying
                  QValueAxis and QLogValueAxis on the same orientation.
                  Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                  and shades can be individually controlled.
              */
              /*!
                  \qmlclass AbstractAxis QAbstractAxis
                  \brief The AbstractAxis is a base element used for specialized axis elements
                  Each series can be bound to only one horizontal and vertical axis.
                  Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                  and shades can be individually controlled.
              */
              /*!
                  \enum QAbstractAxis::AxisType
                  The type of the series object.
                  \value AxisTypeNoAxis
                  \value AxisTypeValue
                  \value AxisTypeBarCategory
                  \value AxisTypeCategory
                  \value AxisTypeDateTime
                  \value AxisTypeLogValue
              */
              /*!
               *\fn void QAbstractAxis::type() const
                Returns the type of the axis
              */
              /*!
                \property QAbstractAxis::lineVisible
                The visibility of the axis line
              */
              /*!
                \qmlproperty bool AbstractAxis::lineVisible
                The visibility of the axis line
              */
              /*!
                \property QAbstractAxis::linePen
                The pen of the line.
              */
              /*!
                \property QAbstractAxis::labelsVisible
                Defines if axis labels are visible.
              */
              /*!
                \qmlproperty bool AbstractAxis::labelsVisible
                Defines if axis labels are visible.
              */
              /*!
                \property QAbstractAxis::labelsPen
                The pen of the labels.
              */
              /*!
                \property QAbstractAxis::labelsBrush
                The brush of the labels.
              */
              /*!
                \property QAbstractAxis::visible
                The visibility of the axis.
              */
              /*!
                \qmlproperty bool AbstractAxis::visible
                The visibility of the axis.
              */
              /*!
                \property QAbstractAxis::gridVisible
                The visibility of the grid lines.
              */
              /*!
                \qmlproperty bool AbstractAxis::gridVisible
                The visibility of the grid lines.
              */
              /*!
                \property QAbstractAxis::color
                The color of the axis and ticks.
              */
              /*!
                \qmlproperty color AbstractAxis::color
                The color of the axis and ticks.
              */
              /*!
                \property QAbstractAxis::gridLinePen
                The pen of the grid line.
              */
              /*!
                \property QAbstractAxis::labelsFont
                The font of the axis labels.
              */
              /*!
                \qmlproperty Font AbstractAxis::labelsFont
                The font of the axis labels.
                See the \l {Font} {QML Font Element} for detailed documentation.
              */
              /*!
                \property QAbstractAxis::labelsColor
                The color of the axis labels.
              */
              /*!
                \qmlproperty color AbstractAxis::labelsColor
                The color of the axis labels.
              */
              /*!
                \property QAbstractAxis::labelsAngle
                The angle of the axis labels in degrees.
              */
              /*!
                \qmlproperty int AbstractAxis::labelsAngle
                The angle of the axis labels in degrees.
              */
              /*!
                \property QAbstractAxis::shadesVisible
                The visibility of the axis shades.
              */
              /*!
                \qmlproperty bool AbstractAxis::shadesVisible
                The visibility of the axis shades.
              */
              /*!
                \property QAbstractAxis::shadesColor
                The fill (brush) color of the axis shades.
              */
              /*!
                \qmlproperty color AbstractAxis::shadesColor
                The fill (brush) color of the axis shades.
              */
              /*!
                \property QAbstractAxis::shadesBorderColor
                The border (pen) color of the axis shades.
              */
              /*!
                \qmlproperty color AbstractAxis::shadesBorderColor
                The border (pen) color of the axis shades.
              */
              /*!
                \property QAbstractAxis::shadesPen
                The pen of the axis shades (area between grid lines).
              */
              /*!
                \property QAbstractAxis::shadesBrush
                The brush of the axis shades (area between grid lines).
              */
              /*!
                \property QAbstractAxis::titleVisible
                The visibility of the axis title. By default the value is true.
              */
              /*!
                \qmlproperty bool AbstractAxis::titleVisible
                The visibility of the axis title. By default the value is true.
              */
              /*!
                \property QAbstractAxis::titleText
                The title of the axis. Empty by default.
              */
              /*!
                \qmlproperty String AbstractAxis::titleText
                The title of the axis. Empty by default.
              */
              /*!
                \property QAbstractAxis::titlePen
                The pen of the title text.
              */
              /*!
                \property QAbstractAxis::titleBrush
                The brush of the title text.
              */
              /*!
                \property QAbstractAxis::titleFont
                The font of the title of the axis.
              */
              /*!
                \qmlproperty Font AbstractAxis::titleFont
                The font of the title of the axis.
              */
              /*!
                \property QAbstractAxis::orientation
                The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
              */
              /*!
                \qmlproperty Qt.Orientation AbstractAxis::orientation
                The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a series.
              */
              /*!
                \property QAbstractAxis::alignment
                The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
              */
              /*!
                \qmlproperty alignment AbstractAxis::alignment
                The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
              */
              /*!
                \fn void QAbstractAxis::visibleChanged(bool visible)
                Visibility of the axis has changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
                Visibility of the axis has changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::linePenChanged(const QPen& pen)
                The pen of the line of the axis has changed to \a pen.
              */
              /*!
                \fn void QAbstractAxis::lineVisibleChanged(bool visible)
                Visibility of the axis line has changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
                Visibility of the axis line has changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
                Visibility of the labels of the axis has changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
                Visibility of the labels of the axis has changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::labelsFontChanged(const QFont& font)
                The font of the axis labels has changed to \a font.
              */
              /*!
                \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
                The font of the axis labels has changed to \a font.
              */
              /*!
                \fn void QAbstractAxis::labelsPenChanged(const QPen& pen)
                The pen of the axis labels has changed to \a pen.
              */
              /*!
                \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
                The brush of the axis labels has changed to \a brush.
              */
              /*!
                \fn void QAbstractAxis::labelsAngleChanged(int angle)
                The angle of the axis labels has changed to \a angle.
              */
              /*!
                \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
                The angle of the axis labels has changed to \a angle.
              */
              /*!
                \fn void QAbstractAxis::gridVisibleChanged(bool visible)
                Visibility of the grid lines of the axis has changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
                Visibility of the grid lines of the axis has changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::gridLinePenChanged(const QPen& pen)
                The pen of the grid line has changed to \a pen.
              */
              /*!
                \fn void QAbstractAxis::colorChanged(QColor color)
                Emitted if the \a color of the axis is changed.
              */
              /*!
                \qmlsignal AbstractAxis::onColorChanged(QColor color)
                Emitted if the \a color of the axis is changed.
              */
              /*!
                \fn void QAbstractAxis::labelsColorChanged(QColor color)
                Emitted if the \a color of the axis labels is changed.
              */
              /*!
                \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
                Emitted if the \a color of the axis labels is changed.
              */
              /*!
                \fn void QAbstractAxis::titleVisibleChanged(bool visible)
                Visibility of the title text of the axis has changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
                Visibility of the title text of the axis has changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::titleTextChanged(const QString& text)
                The text of the axis title has changed to \a text.
              */
              /*!
                \qmlsignal AbstractAxis::onTitleTextChanged(String text)
                The text of the axis title has changed to \a text.
              */
              /*!
                \fn void QAbstractAxis::titlePenChanged(const QPen& pen)
                The pen of the axis shades has changed to \a pen.
              */
              /*!
                \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
                The brush of the axis title has changed to \a brush.
              */
              /*!
                \fn void QAbstractAxis::titleFontChanged(const QFont& font)
                The font of the axis title has changed to \a font.
              */
              /*!
                \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
                The font of the axis title has changed to \a font.
              */
              /*!
                \fn void QAbstractAxis::shadesVisibleChanged(bool)
                Emitted if the visibility of the axis shades is changed to \a visible.
              */
              /*!
                \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
                Emitted if the visibility of the axis shades is changed to \a visible.
              */
              /*!
                \fn void QAbstractAxis::shadesColorChanged(QColor color)
                Emitted if the \a color of the axis shades is changed.
              */
              /*!
                \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
                Emitted if the \a color of the axis shades is changed.
              */
              /*!
                \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
                Emitted if the border \a color of the axis shades is changed.
              */
              /*!
                \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
                Emitted if the border \a color of the axis shades is changed.
              */
              /*!
                \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
                The brush of the axis shades has changed to \a brush.
              */
              /*!
                \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
                The pen of the axis shades has changed to \a pen.
              */
              /*!
               \internal
                Constructs new axis object which is a child of \a parent. Ownership is taken by
                QChart when axis added.
              */
              QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                  : QObject(parent),
                    d_ptr(&d)
              {
              }
              /*!
                Destructor of the axis object. When axis is added to chart, chart object takes ownership.
              */
              QAbstractAxis::~QAbstractAxis()
              {
                  if (d_ptr->m_chart)
                      qFatal("Still binded axis detected !");
              }
              /*!
                Sets \a pen used to draw axis line and ticks.
               */
              void QAbstractAxis::setLinePen(const QPen &pen)
              {
                  if (d_ptr->m_axisPen != pen) {
                      d_ptr->m_axisPen = pen;
                      emit linePenChanged(pen);
                  }
              }
              /*!
                Returns pen used to draw axis and ticks.
              */
              QPen QAbstractAxis::linePen() const
              {
                  return d_ptr->m_axisPen;
              }
              //TODO: remove me 2.0
              void QAbstractAxis::setLinePenColor(QColor color)
              {
                  QPen p = d_ptr->m_axisPen;
                  if (p.color() != color) {
                      p.setColor(color);
                      setLinePen(p);
                      emit colorChanged(color);
                  }
              }
              QColor QAbstractAxis::linePenColor() const
              {
                  return d_ptr->m_axisPen.color();
              }
              /*!
                Sets if axis and ticks are \a visible.
               */
              void QAbstractAxis::setLineVisible(bool visible)
              {
                  if (d_ptr->m_arrowVisible != visible) {
                      d_ptr->m_arrowVisible = visible;
                      emit lineVisibleChanged(visible);
                  }
              }
              bool QAbstractAxis::isLineVisible() const
              {
                  return d_ptr->m_arrowVisible;
              }
              void QAbstractAxis::setGridLineVisible(bool visible)
              {
                  if (d_ptr->m_gridLineVisible != visible) {
                      d_ptr->m_gridLineVisible = visible;
                      emit gridVisibleChanged(visible);
                  }
              }
              bool QAbstractAxis::isGridLineVisible() const
              {
                  return d_ptr->m_gridLineVisible;
              }
              /*!
                Sets \a pen used to draw grid line.
              */
              void QAbstractAxis::setGridLinePen(const QPen &pen)
              {
                  if (d_ptr->m_gridLinePen != pen) {
                      d_ptr->m_gridLinePen = pen;
                      emit gridLinePenChanged(pen);
                  }
              }
              /*!
                Returns pen used to draw grid.
              */
              QPen QAbstractAxis::gridLinePen() const
              {
                  return d_ptr->m_gridLinePen;
              }
              void QAbstractAxis::setLabelsVisible(bool visible)
              {
                  if (d_ptr->m_labelsVisible != visible) {
                      d_ptr->m_labelsVisible = visible;
                      emit labelsVisibleChanged(visible);
                  }
              }
              bool QAbstractAxis::labelsVisible() const
              {
                  return d_ptr->m_labelsVisible;
              }
              /*!
                Sets \a pen used to draw labels.
              */
              void QAbstractAxis::setLabelsPen(const QPen &pen)
              {
                  if (d_ptr->m_labelsPen != pen) {
                      d_ptr->m_labelsPen = pen;
                      emit labelsPenChanged(pen);
                  }
              }
              /*!
                Returns the pen used to labels.
              */
              QPen QAbstractAxis::labelsPen() const
              {
                  return d_ptr->m_labelsPen;
              }
              /*!
                Sets \a brush used to draw labels.
               */
              void QAbstractAxis::setLabelsBrush(const QBrush &brush)
              {
                  if (d_ptr->m_labelsBrush != brush) {
                      d_ptr->m_labelsBrush = brush;
                      emit labelsBrushChanged(brush);
                  }
              }
              /*!
                Returns brush used to draw labels.
              */
              QBrush  QAbstractAxis::labelsBrush() const
              {
                  return d_ptr->m_labelsBrush;
              }
              /*!
                Sets \a font used to draw labels.
              */
              void QAbstractAxis::setLabelsFont(const QFont &font)
              {
                  if (d_ptr->m_labelsFont != font) {
                      d_ptr->m_labelsFont = font;
                      emit labelsFontChanged(font);
                  }
              }
              /*!
                Returns font used to draw labels.
              */
              QFont QAbstractAxis::labelsFont() const
              {
                  return d_ptr->m_labelsFont;
              }
              void QAbstractAxis::setLabelsAngle(int angle)
              {
                  if (d_ptr->m_labelsAngle != angle) {
                      d_ptr->m_labelsAngle = angle;
                      emit labelsAngleChanged(angle);
                  }
              }
              int QAbstractAxis::labelsAngle() const
              {
                  return d_ptr->m_labelsAngle;
              }
              //TODO: remove me 2.0
              void QAbstractAxis::setLabelsColor(QColor color)
              {
                  QBrush b = d_ptr->m_labelsBrush;
                  if (b.color() != color) {
                      b.setColor(color);
                      setLabelsBrush(b);
                      emit labelsColorChanged(color);
                  }
              }
              QColor QAbstractAxis::labelsColor() const
              {
                  return d_ptr->m_labelsBrush.color();
              }
              void QAbstractAxis::setTitleVisible(bool visible)
              {
                  if (d_ptr->m_titleVisible != visible) {
                      d_ptr->m_titleVisible = visible;
                      emit titleVisibleChanged(visible);
                  }
              }
              bool QAbstractAxis::isTitleVisible() const
              {
                  return d_ptr->m_titleVisible;
              }
              /*!
                Sets \a pen used to draw title.
              */
              void QAbstractAxis::setTitlePen(const QPen &pen)
              {
                  if (d_ptr->m_titlePen != pen) {
                      d_ptr->m_titlePen = pen;
                      emit titlePenChanged(pen);
                  }
              }
              /*!
                Returns the pen used to title.
              */
              QPen QAbstractAxis::titlePen() const
              {
                  return d_ptr->m_titlePen;
              }
              /*!
                Sets \a brush used to draw title.
               */
              void QAbstractAxis::setTitleBrush(const QBrush &brush)
              {
                  if (d_ptr->m_titleBrush != brush) {
                      d_ptr->m_titleBrush = brush;
                      emit titleBrushChanged(brush);
                  }
              }
              /*!
                Returns brush used to draw title.
              */
              QBrush  QAbstractAxis::titleBrush() const
              {
                  return d_ptr->m_titleBrush;
              }
              /*!
                Sets \a font used to draw title.
              */
              void QAbstractAxis::setTitleFont(const QFont &font)
              {
                  if (d_ptr->m_titleFont != font) {
                      d_ptr->m_titleFont = font;
                      emit titleFontChanged(font);
                  }
              }
              /*!
                Returns font used to draw title.
              */
              QFont QAbstractAxis::titleFont() const
              {
                  return d_ptr->m_titleFont;
              }
              void QAbstractAxis::setTitleText(const QString &title)
              {
                  if (d_ptr->m_title != title) {
                      d_ptr->m_title = title;
                      emit titleTextChanged(title);
                  }
              }
              QString QAbstractAxis::titleText() const
              {
                  return d_ptr->m_title;
              }
              void QAbstractAxis::setShadesVisible(bool visible)
              {
                  if (d_ptr->m_shadesVisible != visible) {
                      d_ptr->m_shadesVisible = visible;
                      emit shadesVisibleChanged(visible);
                  }
              }
              bool QAbstractAxis::shadesVisible() const
              {
                  return d_ptr->m_shadesVisible;
              }
              /*!
                Sets \a pen used to draw shades.
              */
              void QAbstractAxis::setShadesPen(const QPen &pen)
              {
                  if (d_ptr->m_shadesPen != pen) {
                      d_ptr->m_shadesPen = pen;
                      emit shadesPenChanged(pen);
                  }
              }
              /*!
                Returns pen used to draw shades.
              */
              QPen QAbstractAxis::shadesPen() const
              {
                  return d_ptr->m_shadesPen;
              }
              /*!
                Sets \a brush used to draw shades.
              */
              void QAbstractAxis::setShadesBrush(const QBrush &brush)
              {
                  if (d_ptr->m_shadesBrush != brush) {
                      d_ptr->m_shadesBrush = brush;
                      emit shadesBrushChanged(brush);
                  }
              }
              /*!
                 Returns brush used to draw shades.
              */
              QBrush QAbstractAxis::shadesBrush() const
              {
                  return d_ptr->m_shadesBrush;
              }
              void QAbstractAxis::setShadesColor(QColor color)
              {
                  QBrush b = d_ptr->m_shadesBrush;
                  if (b.color() != color) {
                      b.setColor(color);
                      setShadesBrush(b);
                      emit shadesColorChanged(color);
                  }
              }
              QColor QAbstractAxis::shadesColor() const
              {
                  return d_ptr->m_shadesBrush.color();
              }
              void QAbstractAxis::setShadesBorderColor(QColor color)
              {
              	QPen p = d_ptr->m_shadesPen;
              	if (p.color() != color) {
              		p.setColor(color);
              		setShadesPen(p);
              		emit shadesColorChanged(color);
              	}
              }
              QColor QAbstractAxis::shadesBorderColor() const
              {
                  return d_ptr->m_shadesPen.color();
              }
              bool QAbstractAxis::isVisible() const
              {
                  return d_ptr->m_visible;
              }
              /*!
                Sets axis, shades, labels and grid lines to be visible.
              */
              void QAbstractAxis::setVisible(bool visible)
              {
                  if (d_ptr->m_visible != visible) {
                      d_ptr->m_visible = visible;
                      emit visibleChanged(visible);
                  }
              }
              /*!
                Sets axis, shades, labels and grid lines to be visible.
              */
              void QAbstractAxis::show()
              {
                  setVisible(true);
              }
              /*!
                Sets axis, shades, labels and grid lines to not be visible.
              */
              void QAbstractAxis::hide()
              {
                  setVisible(false);
              }
              /*!
                Sets the minimum value shown on the axis.
                Depending on the actual axis type the \a min parameter is converted to appropriate type.
                If the conversion is impossible then the function call does nothing
              */
              void QAbstractAxis::setMin(const QVariant &min)
              {
                  d_ptr->setMin(min);
              }
              /*!
                Sets the maximum value shown on the axis.
                Depending on the actual axis type the \a max parameter is converted to appropriate type.
                If the conversion is impossible then the function call does nothing
              */
              void QAbstractAxis::setMax(const QVariant &max)
              {
                  d_ptr->setMax(max);
              }
              /*!
                Sets the range shown on the axis.
                Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
                If the conversion is impossible then the function call does nothing.
              */
              void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
              {
                  d_ptr->setRange(min, max);
              }
              /*!
                Returns the orientation in which the axis is being used (Vertical or Horizontal)
              */
              // NOTE: should have const but it breaks BC:
              // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
              Qt::Orientation QAbstractAxis::orientation()
              {
                  return d_ptr->orientation();
              }
              Qt::Alignment QAbstractAxis::alignment() const
              {
                  return d_ptr->alignment();
              }
              /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                  : q_ptr(q),
                    m_chart(0),
                    m_alignment(0),
                    m_orientation(Qt::Orientation(0)),
                    m_visible(true),
                    m_arrowVisible(true),
+                   m_axisPen(QChartPrivate::defaultPen()),
+                   m_axisBrush(QChartPrivate::defaultBrush()),
                    m_gridLineVisible(true),
+                   m_gridLinePen(QChartPrivate::defaultPen()),
                    m_labelsVisible(true),
+                   m_labelsPen(QChartPrivate::defaultPen()),
+                   m_labelsBrush(QChartPrivate::defaultBrush()),
+                   m_labelsFont(QChartPrivate::defaultFont()),
                    m_labelsAngle(0),
                    m_titleVisible(true),
+                   m_titlePen(QChartPrivate::defaultPen()),
+                   m_titleBrush(QChartPrivate::defaultBrush()),
+                   m_titleFont(QChartPrivate::defaultFont()),
                    m_shadesVisible(false),
-                   m_shadesBrush(Qt::SolidPattern),
+                   m_shadesBrush(QChartPrivate::defaultBrush()),
+                   m_shadesPen(QChartPrivate::defaultPen()),
                    m_shadesOpacity(1.0),
                    m_dirty(false)
              {
              }
              QAbstractAxisPrivate::~QAbstractAxisPrivate()
              {
              }
              void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
              {
                  switch(alignment) {
                      case Qt::AlignTop:
                      case Qt::AlignBottom:
                      m_orientation = Qt::Horizontal;
                      break;
                      case Qt::AlignLeft:
                      case Qt::AlignRight:
                      m_orientation = Qt::Vertical;
                      break;
                      default:
                      qWarning()<<"No alignment specified !";
                      break;
                  };
                  m_alignment=alignment;
              }
              void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
              {
-                 QPen pen;
-                 QBrush brush;
-                 QFont font;
+                 //TODO: introduce axis brush
+                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
+                     q_ptr->setLinePen(theme->axisLinePen());
+                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
+                     q_ptr->setGridLinePen(theme->girdLinePen());
+                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
+                     q_ptr->setLabelsBrush(theme->labelBrush());
+                 if (forced || QChartPrivate::defaultPen() == m_labelsPen)
+                     q_ptr->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
+                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
+                     q_ptr->setLabelsFont(theme->labelFont());
+                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
+                     q_ptr->setTitleBrush(theme->labelBrush());
+                 if (forced || QChartPrivate::defaultPen() == m_titlePen)
+                     q_ptr->setTitlePen(Qt::NoPen); // NoPen for performance reasons
+                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
+                     QFont font(m_labelsFont);
+                     font.setBold(true);
+                     q_ptr->setTitleFont(font);
+                 }
-                 bool axisX = m_orientation == Qt::Horizontal;
+                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
+                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
+                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
+                     q_ptr->setShadesPen(theme->backgroundShadesPen());
-                 //TODO: introduce axis brush
-                 if (m_visible) {
-                     if (m_arrowVisible) {
-                         if (forced || pen == m_axisPen) {
-                             q_ptr->setLinePen(theme->axisLinePen());
+                         }
+                     }
-                     if (m_gridLineVisible) {
-                         if (forced || pen == m_gridLinePen) {
-                             q_ptr->setGridLinePen(theme->girdLinePen());
+                         }
+                     }
-                     if (m_labelsVisible) {
-                         if (forced || brush == m_labelsBrush){
-                             q_ptr->setLabelsBrush(theme->labelBrush());
+                         }
-                         if (forced || pen == m_labelsPen){
-                             q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
+                         }
-                         if (forced || font == m_labelsFont){
-                             q_ptr->setLabelsFont(theme->labelFont());
+                         }
+                     }
-                     if (m_titleVisible) {
-                         if (forced || brush == m_titleBrush){
-                             q_ptr->setTitleBrush(theme->labelBrush());
+                         }
-                         if (forced || pen == m_titlePen){
-                             q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
+                         }
-                         if (forced || font == m_titleFont){
-                             QFont font(m_labelsFont);
-                             font.setBold(true);
-                             q_ptr->setTitleFont(font);
+                         }
+                     }
-                     if (forced || m_shadesVisible) {
-                         if (forced || brush == m_shadesBrush){
-                             q_ptr->setShadesBrush(theme->backgroundShadesBrush());
+                         }
-                         if (forced || pen == m_shadesPen){
-                             q_ptr->setShadesPen(theme->backgroundShadesPen());
+                         }
-                         if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
-                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
-                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
-                              q_ptr->setShadesVisible(true);
+                         }
+                     }
+                 bool axisX = m_orientation == Qt::Horizontal;
+                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
+                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
+                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
+                      q_ptr->setShadesVisible(true);
+                 } else if (forced) {
+                     q_ptr->setShadesVisible(false);
                  }
              }
              void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
              {
                  setRange(min,max);
              }
              void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
              {
                  Q_UNUSED(parent);
              }
              void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
              {
                  ChartAxisElement *axis = m_item.data();
                  Q_ASSERT(axis);
                  if (options.testFlag(QChart::GridAxisAnimations)) {
                      axis->setAnimation(new AxisAnimation(axis));
                  } else {
                      axis->setAnimation(0);
                  }
              }
              #include "moc_qabstractaxis.cpp"
              #include "moc_qabstractaxis_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis_p.h +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$
              **
              ****************************************************************************/
              //  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 QABSTRACTAXIS_P_H
              #define QABSTRACTAXIS_P_H
              #include "qabstractaxis.h"
              #include "chartaxiselement_p.h"
              #include "qchart.h"
              #include <QDebug>
              class QGraphicsItem;
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class ChartPresenter;
              class AbstractDomain;
              class QChart;
              class QAbstractSeries;
              class ChartTheme;
              class ChartElement;
              class QTCOMMERCIALCHART_AUTOTEST_EXPORT QAbstractAxisPrivate : public QObject
              {
                  Q_OBJECT
              public:
                  QAbstractAxisPrivate(QAbstractAxis *q);
                  ~QAbstractAxisPrivate();
              public:
                  Qt::Alignment alignment() const { return m_alignment; }
                  Qt::Orientation orientation() const { return m_orientation; }
                  void setAlignment( Qt::Alignment alignment);
                  virtual void initializeDomain(AbstractDomain *domain) = 0;
                  virtual void initializeGraphics(QGraphicsItem *parent) = 0;
                  virtual void initializeTheme(ChartTheme* theme, bool forced = false);
                  virtual void initializeAnimations(QChart::AnimationOptions options);
                  //interface for manipulating range form base class
                  virtual void setMin(const QVariant &min) = 0;
                  virtual void setMax(const QVariant &max) = 0;
                  virtual void setRange(const QVariant &min, const QVariant &max) = 0;
                  //interface manipulating range form domain
                  virtual void setRange(qreal min, qreal max) = 0;
                  virtual qreal min() = 0;
                  virtual qreal max() = 0;
                  ChartAxisElement *axisItem() { return m_item.data(); }
              public Q_SLOTS:
                  void handleRangeChanged(qreal min, qreal max);
              Q_SIGNALS:
                  void rangeChanged(qreal min, qreal max);
              protected:
                  QAbstractAxis *q_ptr;
                  QChart *m_chart;
                  QScopedPointer<ChartAxisElement> m_item;
              private:
                  QList<QAbstractSeries*> m_series;
                  Qt::Alignment m_alignment;
                  Qt::Orientation m_orientation;
                  bool m_visible;
                  bool m_arrowVisible;
                  QPen m_axisPen;
                  QBrush m_axisBrush;
                  bool m_gridLineVisible;
                  QPen m_gridLinePen;
                  bool m_labelsVisible;
                  QPen m_labelsPen;
                  QBrush m_labelsBrush;
                  QFont m_labelsFont;
                  int m_labelsAngle;
                  bool m_titleVisible;
                  QPen m_titlePen;
                  QBrush m_titleBrush;
                  QFont m_titleFont;
                  QString m_title;
                  bool m_shadesVisible;
                  QPen m_shadesPen;
                  QBrush m_shadesBrush;
                  qreal m_shadesOpacity;
                  bool m_dirty;
                  friend class QAbstractAxis;
                  friend class ChartDataSet;
                  friend class ChartPresenter;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif

src/barchart/qabstractbarseries.cpp +4 -6

              /****************************************************************************
              **
              ** 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 "qabstractbarseries.h"
              #include "qabstractbarseries_p.h"
              #include "qbarset.h"
              #include "qbarset_p.h"
              #include "abstractdomain_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "qvalueaxis.h"
              #include "qbarcategoryaxis.h"
              #include "qbarlegendmarker.h"
              #include "baranimation_p.h"
              #include "abstractbarchartitem_p.h"
+             #include "qchart_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QAbstractBarSeries
                  \brief Series for creating a bar chart
                  \mainclass
                  QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                  the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                  and y-value is the height of the bar. The category names are ignored with this series and x-axis
                  shows the x-values.
                  See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                  \image examples_barchart.png
                  \sa QBarSet, QStackedBarSeries, QPercentBarSeries
              */
              /*!
                  \qmlclass AbstractBarSeries QAbstractBarSeries
                  \inherits QAbstractSeries
                  The following QML shows how to create a simple bar chart:
                  \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                  \beginfloatleft
                  \image demos_qmlchart6.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \qmlproperty AbstractAxis AbstractBarSeries::axisX
                  The x axis used for the series. If you leave both axisX and axisXTop undefined, a BarCategoriesAxis is created for
                  the series.
                  \sa axisXTop
              */
              /*!
                  \qmlproperty AbstractAxis AbstractBarSeries::axisY
                  The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                  the series.
                  \sa axisYRight
              */
              /*!
                  \qmlproperty AbstractAxis AbstractBarSeries::axisXTop
                  The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                  axisXTop, but not both.
                  \sa axisX
              */
              /*!
                  \qmlproperty AbstractAxis AbstractBarSeries::axisYRight
                  The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                  or axisYRight, but not both.
                  \sa axisY
              */
              /*!
                  \property QAbstractBarSeries::barWidth
                  The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                  \sa QBarSeries
              */
              /*!
                  \qmlproperty real AbstractBarSeries::barWidth
                  The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
              */
              /*!
                  \property QAbstractBarSeries::count
                  Holds the number of sets in series.
              */
              /*!
                  \qmlproperty int AbstractBarSeries::count
                  Holds the number of sets in series.
              */
              /*!
                  \property QAbstractBarSeries::labelsVisible
                  Defines the visibility of the labels in series
              */
              /*!
                  \qmlproperty bool AbstractBarSeries::labelsVisible
                  Defines the visibility of the labels in series
              */
              /*!
                  \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                  The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                  Clicked bar inside set is indexed by \a index
              */
              /*!
                  \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                  The signal is emitted if the user clicks with a mouse on top of BarSet.
                  Clicked bar inside set is indexed by \a index
              */
              /*!
                  \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                  The signal is emitted if mouse is hovered on top of series.
                  Parameter \a barset is the pointer of barset, where hover happened.
                  Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
              */
              /*!
                  \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
                  The signal is emitted if mouse is hovered on top of series.
                  Parameter \a barset is the pointer of barset, where hover happened.
                  Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
              */
              /*!
                  \fn void QAbstractBarSeries::countChanged()
                  This signal is emitted when barset count has been changed, for example by append or remove.
              */
              /*!
                  \qmlsignal AbstractBarSeries::onCountChanged()
                  This signal is emitted when barset count has been changed, for example by append or remove.
              */
              /*!
                  \fn void QAbstractBarSeries::labelsVisibleChanged()
                  This signal is emitted when labels visibility have changed.
                  \sa isLabelsVisible(), setLabelsVisible()
              */
              /*!
                  \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                  This signal is emitted when \a sets have been added to the series.
                  \sa append(), insert()
              */
              /*!
                  \qmlsignal AbstractBarSeries::onBarsetsAdded(BarSet barset)
                  Emitted when \a barset has been added to the series.
              */
              /*!
                  \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                  This signal is emitted when \a sets have been removed from the series.
                  \sa remove()
              */
              /*!
                  \qmlsignal AbstractBarSeries::onBarsetsRemoved(BarSet barset)
                  Emitted when \a barset has been removed from the series.
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::at(int index)
                  Returns bar set at \a index. Returns null if the index is not valid.
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                  Adds a new bar set with \a label and \a values to \a index. Values is a list of reals.
                  For example:
                  \code
                      myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                  \endcode
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                  Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                  If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                  appended.
                  \sa AbstractBarSeries::append()
              */
              /*!
                  \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                  Removes the barset from the series. Returns true if successful, false otherwise.
              */
              /*!
                  \qmlmethod AbstractBarSeries::clear()
                  Removes all barsets from the series.
              */
              /*!
                  Destructs abstractbarseries and owned barsets.
              */
              QAbstractBarSeries::~QAbstractBarSeries()
              {
              }
              /*!
                  \internal
              */
              QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
                  : QAbstractSeries(o, parent)
              {
                  Q_D(QAbstractSeries);
                  QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
              }
              /*!
                  Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
              */
              void QAbstractBarSeries::setBarWidth(qreal width)
              {
                  Q_D(QAbstractBarSeries);
                  d->setBarWidth(width);
              }
              /*!
                  Returns the width of the bars of the series.
                  \sa setBarWidth()
              */
              qreal QAbstractBarSeries::barWidth() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->barWidth();
              }
              /*!
                  Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                  Returns true, if appending succeeded.
              */
              bool QAbstractBarSeries::append(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->append(set);
                  if (success) {
                      QList<QBarSet *> sets;
                      sets.append(set);
                      set->setParent(this);
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                  was successful.
                  Returns true, if set was removed.
              */
              bool QAbstractBarSeries::remove(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->remove(set);
                  if (success) {
                      QList<QBarSet *> sets;
                      sets.append(set);
                      set->setParent(0);
                      emit barsetsRemoved(sets);
                      emit countChanged();
                      delete set;
                      set = 0;
                  }
                  return success;
              }
              /*!
                  Takes a single \a set from the series. Does not delete the barset object.
                  NOTE: The series remains as the barset's parent object. You must set the
                  parent object to take full ownership.
                  Returns true if take was successful.
              */
              bool QAbstractBarSeries::take(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->remove(set);
                  if (success) {
                      QList<QBarSet *> sets;
                      sets.append(set);
                      emit barsetsRemoved(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Adds a list of barsets to series. Takes ownership of \a sets.
                  Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                  nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                  and function returns false.
              */
              bool QAbstractBarSeries::append(QList<QBarSet *> sets)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->append(sets);
                  if (success) {
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                  Returns true, if inserting succeeded.
              */
              bool QAbstractBarSeries::insert(int index, QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->insert(index, set);
                  if (success) {
                      QList<QBarSet *> sets;
                      sets.append(set);
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Removes all barsets from the series. Deletes removed sets.
              */
              void QAbstractBarSeries::clear()
              {
                  Q_D(QAbstractBarSeries);
                  QList<QBarSet *> sets = barSets();
                  bool success = d->remove(sets);
                  if (success) {
                      emit barsetsRemoved(sets);
                      emit countChanged();
                      foreach (QBarSet *set, sets)
                          delete set;
                  }
              }
              /*!
                  Returns number of sets in series.
              */
              int QAbstractBarSeries::count() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_barSets.count();
              }
              /*!
                  Returns a list of sets in series. Keeps ownership of sets.
               */
              QList<QBarSet *> QAbstractBarSeries::barSets() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_barSets;
              }
              /*!
                  Sets the visibility of labels in series to \a visible
              */
              void QAbstractBarSeries::setLabelsVisible(bool visible)
              {
                  Q_D(QAbstractBarSeries);
                  if (d->m_labelsVisible != visible) {
                      d->setLabelsVisible(visible);
                      emit labelsVisibleChanged();
                  }
              }
              /*!
                  Returns the visibility of labels
              */
              bool QAbstractBarSeries::isLabelsVisible() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_labelsVisible;
              }
              ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                  QAbstractSeriesPrivate(q),
                  m_barWidth(0.5),  // Default value is 50% of category width
                  m_labelsVisible(false),
                  m_visible(true)
              {
              }
              int QAbstractBarSeriesPrivate::categoryCount() const
              {
                  // No categories defined. return count of longest set.
                  int count = 0;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      if (m_barSets.at(i)->count() > count)
                          count = m_barSets.at(i)->count();
                  }
                  return count;
              }
              void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
              {
                  if (width < 0.0)
                      width = 0.0;
                  m_barWidth = width;
                  emit updatedLayout();
              }
              qreal QAbstractBarSeriesPrivate::barWidth() const
              {
                  return m_barWidth;
              }
              QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
              {
                  return m_barSets.at(index);
              }
              void QAbstractBarSeriesPrivate::setVisible(bool visible)
              {
                  m_visible = visible;
                  emit visibleChanged();
              }
              void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
              {
                  m_labelsVisible = visible;
                  emit labelsVisibleChanged(visible);
              }
              qreal QAbstractBarSeriesPrivate::min()
              {
                  if (m_barSets.count() <= 0)
                      return 0;
                  qreal min = INT_MAX;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->at(j);
                          if (temp < min)
                              min = temp;
                      }
                  }
                  return min;
              }
              qreal QAbstractBarSeriesPrivate::max()
              {
                  if (m_barSets.count() <= 0)
                      return 0;
                  qreal max = INT_MIN;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->at(j);
                          if (temp > max)
                              max = temp;
                      }
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
              {
                  if ((set < 0) || (set >= m_barSets.count()))
                      return 0; // No set, no value.
                  else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                      return 0; // No category, no value.
                  return m_barSets.at(set)->at(category);
              }
              qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
              {
                  if ((set < 0) || (set >= m_barSets.count()))
                      return 0; // No set, no value.
                  else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                      return 0; // No category, no value.
                  qreal value = m_barSets.at(set)->at(category);
                  qreal sum = categorySum(category);
                  if (qFuzzyCompare(sum, 0))
                      return 0;
                  return value / sum;
              }
              qreal QAbstractBarSeriesPrivate::categorySum(int category)
              {
                  qreal sum(0);
                  int count = m_barSets.count(); // Count sets
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count())
                          sum += m_barSets.at(set)->at(category);
                  }
                  return sum;
              }
              qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
              {
                  qreal sum(0);
                  int count = m_barSets.count(); // Count sets
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count())
                          sum += qAbs(m_barSets.at(set)->at(category));
                  }
                  return sum;
              }
              qreal QAbstractBarSeriesPrivate::maxCategorySum()
              {
                  qreal max = INT_MIN;
                  int count = categoryCount();
                  for (int i = 0; i < count; i++) {
                      qreal sum = categorySum(i);
                      if (sum > max)
                          max = sum;
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::minX()
              {
                  if (m_barSets.count() <= 0)
                      return 0;
                  qreal min = INT_MAX;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                          if (temp < min)
                              min = temp;
                      }
                  }
                  return min;
              }
              qreal QAbstractBarSeriesPrivate::maxX()
              {
                  if (m_barSets.count() <= 0)
                      return 0;
                  qreal max = INT_MIN;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                          if (temp > max)
                              max = temp;
                      }
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::categoryTop(int category)
              {
                  // Returns top (sum of all positive values) of category.
                  // Returns 0, if all values are negative
                  qreal top(0);
                  int count = m_barSets.count();
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count()) {
                          qreal temp = m_barSets.at(set)->at(category);
                          if (temp > 0) {
                              top += temp;
                          }
                      }
                  }
                  return top;
              }
              qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
              {
                  // Returns bottom (sum of all negative values) of category
                  // Returns 0, if all values are positive
                  qreal bottom(0);
                  int count = m_barSets.count();
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count()) {
                          qreal temp = m_barSets.at(set)->at(category);
                          if (temp < 0) {
                              bottom += temp;
                          }
                      }
                  }
                  return bottom;
              }
              qreal QAbstractBarSeriesPrivate::top()
              {
                  // Returns top of all categories
                  qreal top(0);
                  int count = categoryCount();
                  for (int i = 0; i < count; i++) {
                      qreal temp = categoryTop(i);
                      if (temp > top)
                          top = temp;
                  }
                  return top;
              }
              qreal QAbstractBarSeriesPrivate::bottom()
              {
                  // Returns bottom of all categories
                  qreal bottom(0);
                  int count = categoryCount();
                  for (int i = 0; i < count; i++) {
                      qreal temp = categoryBottom(i);
                      if (temp < bottom)
                          bottom = temp;
                  }
                  return bottom;
              }
              void QAbstractBarSeriesPrivate::initializeDomain()
              {
                  qreal minX(domain()->minX());
                  qreal minY(domain()->minY());
                  qreal maxX(domain()->maxX());
                  qreal maxY(domain()->maxY());
                  qreal seriesMinX = this->minX();
                  qreal seriesMaxX = this->maxX();
                  qreal y = max();
                  minX = qMin(minX, seriesMinX - (qreal)0.5);
                  minY = qMin(minY, y);
                  maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                  maxY = qMax(maxY, y);
                  domain()->setRange(minX, maxX, minY, maxY);
              }
              QList<QLegendMarker*> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend* legend)
              {
                  Q_Q(QAbstractBarSeries);
                  QList<QLegendMarker*> markers;
                  foreach(QBarSet* set, q->barSets()) {
                      QBarLegendMarker* marker = new QBarLegendMarker(q,set,legend);
                      markers << marker;
                  }
                  return markers;
              }
              bool QAbstractBarSeriesPrivate::append(QBarSet *set)
              {
                  if ((m_barSets.contains(set)) || (set == 0))
                      return false; // Fail if set is already in list or set is null.
                  m_barSets.append(set);
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  emit restructuredBars(); // this notifies barchartitem
                  return true;
              }
              bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
              {
                  if (!m_barSets.contains(set))
                      return false; // Fail if set is not in list
                  m_barSets.removeOne(set);
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  emit restructuredBars(); // this notifies barchartitem
                  return true;
              }
              bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
              {
                  foreach (QBarSet *set, sets) {
                      if ((set == 0) || (m_barSets.contains(set)))
                          return false; // Fail if any of the sets is null or is already appended.
                      if (sets.count(set) != 1)
                          return false; // Also fail if same set is more than once in given list.
                  }
                  foreach (QBarSet *set, sets) {
                      m_barSets.append(set);
                      QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                      QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                      QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  }
                  emit restructuredBars(); // this notifies barchartitem
                  return true;
              }
              bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
              {
                  if (sets.count() == 0)
                      return false;
                  foreach (QBarSet *set, sets) {
                      if ((set == 0) || (!m_barSets.contains(set)))
                          return false; // Fail if any of the sets is null or is not in series
                      if (sets.count(set) != 1)
                          return false; // Also fail if same set is more than once in given list.
                  }
                  foreach (QBarSet *set, sets) {
                      m_barSets.removeOne(set);
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  }
                  emit restructuredBars();        // this notifies barchartitem
                  return true;
              }
              bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
              {
                  if ((m_barSets.contains(set)) || (set == 0))
                      return false; // Fail if set is already in list or set is null.
                  m_barSets.insert(index, set);
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  emit restructuredBars();      // this notifies barchartitem
                  return true;
              }
              void QAbstractBarSeriesPrivate::initializeAxes()
              {
                  Q_Q(QAbstractBarSeries);
                  foreach(QAbstractAxis* axis, m_axes) {
                      if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                          switch (q->type()) {
                              case QAbstractSeries::SeriesTypeHorizontalBar:
                              case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                              case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                              if (axis->orientation() == Qt::Vertical)
                              populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                              break;
                              case QAbstractSeries::SeriesTypeBar:
                              case QAbstractSeries::SeriesTypePercentBar:
                              case QAbstractSeries::SeriesTypeStackedBar:
                              if (axis->orientation() == Qt::Horizontal)
                              populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                              break;
                              default:
                              qWarning() << "Unexpected series type";
                              break;
                          }
                      }
                  }
              }
              QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
              {
                  Q_Q(const QAbstractBarSeries);
                  switch (q->type()) {
                  case QAbstractSeries::SeriesTypeHorizontalBar:
                  case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                  case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                      if (orientation == Qt::Vertical)
                          return QAbstractAxis::AxisTypeBarCategory;
                      break;
                  case QAbstractSeries::SeriesTypeBar:
                  case QAbstractSeries::SeriesTypePercentBar:
                  case QAbstractSeries::SeriesTypeStackedBar:
                      if (orientation == Qt::Horizontal)
                          return QAbstractAxis::AxisTypeBarCategory;
                      break;
                  default:
                      qWarning() << "Unexpected series type";
                      break;
                  }
                  return QAbstractAxis::AxisTypeValue;
              }
              void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
              {
                  QStringList categories;
                  if (axis->categories().isEmpty()) {
                      for (int i(1); i < categoryCount() + 1; i++)
                          categories << QString::number(i);
                      axis->append(categories);
                  }
              }
              QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
              {
                  Q_UNUSED(orientation);
                  return 0;
              }
              void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
              {
                  const QList<QGradient> gradients = theme->seriesGradients();
-                 QBrush brush;
-                 QPen pen;
                  qreal takeAtPos = 0.5;
                  qreal step = 0.2;
                  if (m_barSets.count() > 1) {
                      step = 1.0 / (qreal) m_barSets.count();
                      if (m_barSets.count() % gradients.count())
                      step *= gradients.count();
                      else
                      step *= (gradients.count() - 1);
                  }
                  for (int i(0); i < m_barSets.count(); i++) {
                      int colorIndex = (index + i) % gradients.count();
                      if (i > 0 && i %gradients.count() == 0) {
                          // There is no dedicated base color for each sets, generate more colors
                          takeAtPos += step;
                          if (takeAtPos == 1.0)
                          takeAtPos += step;
                          takeAtPos -= (int) takeAtPos;
                      }
-                     if (forced || brush == m_barSets.at(i)->brush())
+                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->brush())
                          m_barSets.at(i)->setBrush(ChartThemeManager::colorAt(gradients.at(colorIndex), takeAtPos));
                      // Pick label color from the opposite end of the gradient.
                      // 0.3 as a boundary seems to work well.
-                     if (forced || brush == m_barSets.at(i)->labelBrush()) {
+                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->labelBrush()) {
                          if (takeAtPos < 0.3)
                              m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1));
                          else
                              m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0));
                      }
-                     if (forced || pen == m_barSets.at(i)->pen()) {
+                     if (forced || QChartPrivate::defaultPen() == m_barSets.at(i)->pen()) {
                          QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                          m_barSets.at(i)->setPen(c);
                      }
                  }
              }
              void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
              {
                  AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
                  Q_ASSERT(bar);
                  if (options.testFlag(QChart::SeriesAnimations)) {
                      bar->setAnimation(new BarAnimation(bar));
                  }else{
                      bar->setAnimation(0);
                  }
                  QAbstractSeriesPrivate::initializeAnimations(options);
              }
              #include "moc_qabstractbarseries.cpp"
              #include "moc_qabstractbarseries_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +5 -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 "qbarset.h"
              #include "qbarset_p.h"
              #include "charthelpers_p.h"
+             #include "qchart_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QBarSet
                  \brief Building block for different bar charts
                  QBarSet represents one set of bars. Set of bars contains one data value for each category.
                  First value of set is assumed to belong to first category, second to second category and so on.
                  If set has fewer values than there are categories, then the missing values are assumed to be
                  at the end of set. For missing values in middle of a set, numerical value of zero is used.
                  \mainclass
                  \sa QAbstractBarSeries, QBarSeries, QStackedBarSeries, QPercentBarSeries
              */
              /*!
                  \qmlclass BarSet QBarSet
                  BarSet represents one set of bars. Set of bars contains one data value for each category.
                  First value of set is assumed to belong to first category, second to second category and so on.
                  If set has fewer values than there are categories, then the missing values are assumed to be
                  at the end of set. For missing values in middle of a set, numerical value of zero is used.
                  \sa AbstractBarSeries, BarSeries, StackedBarSeries, PercentBarSeries
              */
              /*!
                  \property QBarSet::label
                  Defines the label of the barSet.
              */
              /*!
                  \qmlproperty string BarSet::label
                  Defines the label of the barSet.
              */
              /*!
                  \property QBarSet::pen
                  \brief Defines the pen used by the barSet.
              */
              /*!
                  \property QBarSet::brush
                  \brief Defines the brush used by the barSet.
              */
              /*!
                  \property QBarSet::labelBrush
                  \brief Defines the brush used by the barSet's label.
              */
              /*!
                  \property QBarSet::labelFont
                  \brief Defines the font used by the barSet's label.
              */
              /*!
                  \qmlproperty Font BarSet::labelFont
                  Defines the font used by the barSet's label.
                  See the \l {Font} {QML Font Element} for detailed documentation.
              */
              /*!
                  \property QBarSet::color
                  The fill (brush) color of the bar set.
              */
              /*!
                  \qmlproperty color BarSet::color
                  The fill (brush) color of the bar set.
              */
              /*!
                  \property QBarSet::borderColor
                  The line (pen) color of the bar set.
              */
              /*!
                  \qmlproperty color BarSet::borderColor
                  The line (pen) color of the bar set.
              */
              /*!
                  \qmlproperty real BarSet::borderWidth
                  The width of the border line. By default the width is 2.0.
              */
              /*!
                  \property QBarSet::labelColor
                  The text (label) color of the bar set.
              */
              /*!
                  \qmlproperty color BarSet::labelColor
                  The text (label) color of the bar set.
              */
              /*!
                  \fn void QBarSet::clicked(int index)
                  The signal is emitted if the user clicks with a mouse on top of barset.
                  Clicked bar inside set is indexed by \a index
              */
              /*!
                  \fn void QBarSet::hovered(bool status)
                  The signal is emitted if mouse is hovered on top of barset.
                  Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
              */
              /*!
                  \fn void QBarSet::labelChanged()
                  This signal is emitted when the label of the barSet has changed.
                  \sa label
              */
              /*!
                  \qmlsignal BarSet::onLabelChanged()
                  This signal is emitted when the label of the barSet has changed.
              */
              /*!
                  \fn void QBarSet::penChanged()
                  This signal is emitted when the pen of the barSet has changed.
                  \sa pen
              */
              /*!
                  \fn void QBarSet::brushChanged()
                  This signal is emitted when the brush of the barSet has changed.
                  \sa brush
              */
              /*!
                  \fn void QBarSet::labelBrushChanged()
                  This signal is emitted when the brush of the barSet's label has changed.
                  \sa labelBrush
              */
              /*!
                  \fn void QBarSet::labelFontChanged()
                  This signal is emitted when the font of the barSet's label has changed.
                  \sa labelBrush
              */
              /*!
                  \fn void QBarSet::colorChanged(QColor)
                  This signal is emitted when the fill (brush) color of the set has changed to \a color.
              */
              /*!
                  \qmlsignal BarSet::onColorChanged(color color)
                  This signal is emitted when the fill (brush) color of the set has changed to \a color.
              */
              /*!
                  \fn void QBarSet::borderColorChanged(QColor)
                  This signal is emitted when the line (pen) color of the set has changed to \a color.
              */
              /*!
                  \qmlsignal BarSet::onBorderColorChanged(color color)
                  This signal is emitted when the line (pen) color of the set has changed to \a color.
              */
              /*!
                  \fn void QBarSet::labelColorChanged(QColor)
                  This signal is emitted when the text (label) color of the set has changed to \a color.
              */
              /*!
                  \qmlsignal BarSet::onLabelColorChanged(color color)
                  This signal is emitted when the text (label) color of the set has changed to \a color.
              */
              /*!
                  \fn void QBarSet::valuesAdded(int index, int count)
                  This signal is emitted when new values have been added to the set.
                  Parameter \a index indicates the position of the first inserted value.
                  Parameter \a count is the number of inserted values.
                  \sa append(), insert()
              */
              /*!
                  \qmlsignal BarSet::onValuesAdded(int index, int count)
                  This signal is emitted when new values have been added to the set.
                  Parameter \a index indicates the position of the first inserted value.
                  Parameter \a count is the number of inserted values.
              */
              /*!
                  \fn void QBarSet::valuesRemoved(int index, int count)
                  This signal is emitted values have been removed from the set.
                  Parameter \a index indicates the position of the first removed value.
                  Parameter \a count is the number of removed values.
                  \sa remove()
              */
              /*!
                  \qmlsignal BarSet::onValuesRemoved(int index, int count)
                  This signal is emitted values have been removed from the set.
                  Parameter \a index indicates the position of the first removed value.
                  Parameter \a count is the number of removed values.
              */
              /*!
                  \fn void QBarSet::valueChanged(int index)
                  This signal is emitted values the value in the set has been modified.
                  Parameter \a index indicates the position of the modified value.
                  \sa at()
              */
              /*!
                  \qmlsignal BarSet::onValueChanged(int index)
                  This signal is emitted values the value in the set has been modified.
                  Parameter \a index indicates the position of the modified value.
              */
              /*!
                  \qmlproperty int BarSet::count
                  The count of values on the barset
              */
              /*!
                  \qmlproperty QVariantList BarSet::values
                  The values of the barset. You can set either a list of reals or a list of points as values. If you set a list of
                  reals as values, the values are automatically completed to points by using the index of a value as it's
                  x-coordinate. For example:
                  \code
                      myBarSet1.values = [0, 5, 1, 5];
                      myBarSet2.values = [Qt.point(0, 1), Qt.point(1, 5), Qt.point(2.2, 4.3)];
                  \endcode
              */
              /*!
                  Constructs QBarSet with a label of \a label and with parent of \a parent.
              */
              QBarSet::QBarSet(const QString label, QObject *parent)
                  : QObject(parent),
                    d_ptr(new QBarSetPrivate(label, this))
              {
              }
              /*!
                  Destroys the barset.
              */
              QBarSet::~QBarSet()
              {
                  // NOTE: d_ptr destroyed by QObject
              }
              /*!
                  Sets new \a label for set.
              */
              void QBarSet::setLabel(const QString label)
              {
                  d_ptr->m_label = label;
                  emit labelChanged();
              }
              /*!
                  Returns label of the set.
              */
              QString QBarSet::label() const
              {
                  return d_ptr->m_label;
              }
              /*!
                  Appends new value \a value to the end of set.
              */
              void QBarSet::append(const qreal value)
              {
                  // Convert to QPointF
                  int index = d_ptr->m_values.count();
                  d_ptr->append(QPointF(d_ptr->m_values.count(), value));
                  emit valuesAdded(index, 1);
              }
              /*!
                  Appends a list of reals to set. Works like append with single real value. The \a values in list
                  are appended to end of barset
                  \sa append()
              */
              void QBarSet::append(const QList<qreal> &values)
              {
                  int index = d_ptr->m_values.count();
                  d_ptr->append(values);
                  emit valuesAdded(index, values.count());
              }
              /*!
                  Convenience operator. Same as append, with real \a value.
                  \sa append()
              */
              QBarSet &QBarSet::operator << (const qreal &value)
              {
                  append(value);
                  return *this;
              }
              /*!
                  Inserts new \a value on the \a index position.
                  The value that is currently at this postion is moved to position index + 1
                  \sa remove()
              */
              void QBarSet::insert(const int index, const qreal value)
              {
                  d_ptr->insert(index, value);
                  emit valuesAdded(index, 1);
              }
              /*!
                  Removes \a count number of values from the set starting at \a index.
                  \sa insert()
              */
              void QBarSet::remove(const int index, const int count)
              {
                  int removedCount = d_ptr->remove(index, count);
                  if (removedCount > 0)
                      emit valuesRemoved(index, removedCount);
                  return;
              }
              /*!
                  Sets a new value \a value to set, indexed by \a index.
              */
              void QBarSet::replace(const int index, const qreal value)
              {
                  if (index >= 0 && index < d_ptr->m_values.count()) {
                      d_ptr->replace(index, value);
                      emit valueChanged(index);
                  }
              }
              /*!
                  Returns value of set indexed by \a index.
                  If the index is out of bounds 0.0 is returned.
              */
              qreal QBarSet::at(const int index) const
              {
                  if (index < 0 || index >= d_ptr->m_values.count())
                      return 0;
                  return d_ptr->m_values.at(index).y();
              }
              /*!
                  Returns value of set indexed by \a index.
                  If the index is out of bounds 0.0 is returned.
              */
              qreal QBarSet::operator [](const int index) const
              {
                  return at(index);
              }
              /*!
                  Returns count of values in set.
              */
              int QBarSet::count() const
              {
                  return d_ptr->m_values.count();
              }
              /*!
                  Returns sum of all values in barset.
              */
              qreal QBarSet::sum() const
              {
                  qreal total(0);
                  for (int i = 0; i < d_ptr->m_values.count(); i++)
                      total += d_ptr->m_values.at(i).y();
                  return total;
              }
              /*!
                  Sets pen for set. Bars of this set are drawn using \a pen
              */
              void QBarSet::setPen(const QPen &pen)
              {
                  if (d_ptr->m_pen != pen) {
                      d_ptr->m_pen = pen;
                      emit d_ptr->updatedBars();
                      emit penChanged();
                  }
              }
              /*!
                  Returns pen of the set.
              */
              QPen QBarSet::pen() const
              {
                  return d_ptr->m_pen;
              }
              /*!
                  Sets brush for the set. Bars of this set are drawn using \a brush
              */
              void QBarSet::setBrush(const QBrush &brush)
              {
                  if (d_ptr->m_brush != brush) {
                      d_ptr->m_brush = brush;
                      emit d_ptr->updatedBars();
                      emit brushChanged();
                  }
              }
              /*!
                  Returns brush of the set.
              */
              QBrush QBarSet::brush() const
              {
                  return d_ptr->m_brush;
              }
              /*!
                  Sets \a brush of the values that are drawn on top of this barset
              */
              void QBarSet::setLabelBrush(const QBrush &brush)
              {
                  if (d_ptr->m_labelBrush != brush) {
                      d_ptr->m_labelBrush = brush;
                      emit d_ptr->updatedBars();
                      emit labelBrushChanged();
                  }
              }
              /*!
                  Returns brush of the values that are drawn on top of this barset
              */
              QBrush QBarSet::labelBrush() const
              {
                  return d_ptr->m_labelBrush;
              }
              /*!
                  Sets the \a font for values that are drawn on top of this barset
              */
              void QBarSet::setLabelFont(const QFont &font)
              {
                  if (d_ptr->m_labelFont != font) {
                      d_ptr->m_labelFont = font;
                      emit d_ptr->updatedBars();
                      emit labelFontChanged();
                  }
              }
              /*!
                  Returns the pen for values that are drawn on top of this barset
              */
              QFont QBarSet::labelFont() const
              {
                  return d_ptr->m_labelFont;
              }
              /*!
                  Returns the color of the brush of barset.
              */
              QColor QBarSet::color()
              {
                  return brush().color();
              }
              /*!
                  Sets the \a color of brush for this barset
              */
              void QBarSet::setColor(QColor color)
              {
                  QBrush b = brush();
                  if ((b.color() != color) || (b.style() == Qt::NoBrush)) {
                      b.setColor(color);
                      if (b.style() == Qt::NoBrush) {
                          // Set tyle to Qt::SolidPattern. (Default is Qt::NoBrush)
                          // This prevents theme to override color defined in QML side:
                          // BarSet { label: "Bob"; color:"red"; values: [1,2,3] }
                          // The color must be obeyed, since user wanted it.
                          b.setStyle(Qt::SolidPattern);
                      }
                      setBrush(b);
                      emit colorChanged(color);
                  }
              }
              /*!
                  Returns the color of pen of this barset
              */
              QColor QBarSet::borderColor()
              {
                  return pen().color();
              }
              /*!
                  Sets the color of pen for this barset
              */
              void QBarSet::setBorderColor(QColor color)
              {
                  QPen p = pen();
                  if (p.color() != color) {
                      p.setColor(color);
                      setPen(p);
                      emit borderColorChanged(color);
                  }
              }
              /*!
                  Returns the color of labels of this barset
              */
              QColor QBarSet::labelColor()
              {
                  return labelBrush().color();
              }
              /*!
                  Sets the color of labels for this barset
              */
              void QBarSet::setLabelColor(QColor color)
              {
                  QBrush b = labelBrush();
                  if (b == QBrush())
                      b.setStyle(Qt::SolidPattern);
                  if (b.color() != color) {
                      b.setColor(color);
                      setLabelBrush(b);
                      emit labelColorChanged(color);
                  }
              }
              ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                  q_ptr(parent),
-                 m_label(label)
+                 m_label(label),
+                 m_pen(QChartPrivate::defaultPen()),
+                 m_brush(QChartPrivate::defaultBrush()),
+                 m_labelBrush(QChartPrivate::defaultBrush())
              {
              }
              QBarSetPrivate::~QBarSetPrivate()
              {
              }
              void QBarSetPrivate::append(QPointF value)
              {
                  if (isValidValue(value)) {
                      m_values.append(value);
                      emit restructuredBars();
                  }
              }
              void QBarSetPrivate::append(QList<QPointF> values)
              {
                  for (int i = 0; i < values.count(); i++) {
                      if (isValidValue(values.at(i)))
                          m_values.append(values.at(i));
                  }
                  emit restructuredBars();
              }
              void QBarSetPrivate::append(QList<qreal> values)
              {
                  int index = m_values.count();
                  for (int i = 0; i < values.count(); i++) {
                      if (isValidValue(values.at(i))) {
                          m_values.append(QPointF(index, values.at(i)));
                          index++;
                      }
                  }
                  emit restructuredBars();
              }
              void QBarSetPrivate::insert(const int index, const qreal value)
              {
                  m_values.insert(index, QPointF(index, value));
                  emit restructuredBars();
              }
              void QBarSetPrivate::insert(const int index, const QPointF value)
              {
                  m_values.insert(index, value);
                  emit restructuredBars();
              }
              int QBarSetPrivate::remove(const int index, const int count)
              {
                  int removeCount = count;
                  if ((index < 0) || (m_values.count() == 0))
                      return 0; // Invalid index or not values in list, remove nothing.
                  else if ((index + count) > m_values.count())
                      removeCount = m_values.count() - index; // Trying to remove more items than list has. Limit amount to be removed.
                  int c = 0;
                  while (c < removeCount) {
                      m_values.removeAt(index);
                      c++;
                  }
                  emit restructuredBars();
                  return removeCount;
              }
              void QBarSetPrivate::replace(const int index, const qreal value)
              {
                  m_values.replace(index, QPointF(index, value));
                  emit updatedLayout();
              }
              void QBarSetPrivate::replace(const int index, const QPointF value)
              {
                  m_values.replace(index, value);
                  emit updatedLayout();
              }
              qreal QBarSetPrivate::pos(const int index)
              {
                  if (index < 0 || index >= m_values.count())
                      return 0;
                  return m_values.at(index).x();
              }
              qreal QBarSetPrivate::value(const int index)
              {
                  if (index < 0 || index >= m_values.count())
                      return 0;
                  return m_values.at(index).y();
              }
              #include "moc_qbarset.cpp"
              #include "moc_qbarset_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +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$
               **
               ****************************************************************************/
              #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->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
+                     m_background->setBrush(QChartPrivate::defaultBrush());
                      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/chartthememanager.cpp +31 -50

              /****************************************************************************
              **
              ** 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())
+                 {
+                 if (m_theme.isNull() || theme != m_theme->id()) {
                      switch (theme) {
-                         case QChart::ChartThemeLight:
+                     case QChart::ChartThemeLight:
                          m_theme.reset(new ChartThemeLight());
                          break;
-                         case QChart::ChartThemeBlueCerulean:
+                     case QChart::ChartThemeBlueCerulean:
                          m_theme.reset(new ChartThemeBlueCerulean());
                          break;
-                         case QChart::ChartThemeDark:
+                     case QChart::ChartThemeDark:
                          m_theme.reset(new ChartThemeDark());
                          break;
-                         case QChart::ChartThemeBrownSand:
+                     case QChart::ChartThemeBrownSand:
                          m_theme.reset(new ChartThemeBrownSand());
                          break;
-                         case QChart::ChartThemeBlueNcs:
+                     case QChart::ChartThemeBlueNcs:
                          m_theme.reset(new ChartThemeBlueNcs());
                          break;
-                         case QChart::ChartThemeHighContrast:
+                     case QChart::ChartThemeHighContrast:
                          m_theme.reset(new ChartThemeHighContrast());
                          break;
-                         case QChart::ChartThemeBlueIcy:
+                     case QChart::ChartThemeBlueIcy:
                          m_theme.reset(new ChartThemeBlueIcy());
                          break;
-                         default:
+                     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);
+                         }
+                     if (!m_theme.isNull()) {
+                         decorateChart(m_chart,m_theme.data());
+                         decorateLegend(m_chart->legend(),m_theme.data());
+                         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
+             // decorateChart is only called when theme is forcibly initialized
+             void ChartThemeManager::decorateChart(QChart *chart, ChartTheme *theme) const
              {
-                 QBrush brush;
-                 if (force || brush == chart->backgroundBrush())
-                     chart->setBackgroundBrush(theme->chartBackgroundGradient());
+                 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);
+                 }
+                 QPen pen(Qt::transparent);
+                 QBrush brush;
+                 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
+             // decorateLegend is only called when theme is forcibly initialized
+             void ChartThemeManager::decorateLegend(QLegend *legend, ChartTheme *theme) 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());
+                 legend->setPen(theme->axisLinePen());
+                 legend->setBrush(theme->chartBackgroundGradient());
+                 legend->setFont(theme->labelFont());
+                 legend->setLabelBrush(theme->labelBrush());
              }
-             int  ChartThemeManager::createIndexKey(QList<int> keys) const
+             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/chartthememanager_p.h +2 -2

              /****************************************************************************
              **
              ** 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 CHARTTHEMEMANAGER_H
              #define CHARTTHEMEMANAGER_H
              #include "qchartglobal.h"
              #include "qchart.h"
              #include <QColor>
              #include <QGradientStops>
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class ChartTheme;
              class ChartThemeManager: public QObject
              {
                  Q_OBJECT
              public:
                  enum BackgroundShadesMode {
                      BackgroundShadesNone = 0,
                      BackgroundShadesVertical,
                      BackgroundShadesHorizontal,
                      BackgroundShadesBoth
                  };
              public:
                  explicit ChartThemeManager(QChart* chart);
                  void setTheme(QChart::ChartTheme theme);
                  ChartTheme* theme() const { return m_theme.data(); }
-                 void decorateChart(QChart *chart, ChartTheme* theme, bool force = false) const;
-                 void decorateLegend(QLegend *legend, ChartTheme* theme, bool force = false) const;
+                 void decorateChart(QChart *chart, ChartTheme* theme) const;
+                 void decorateLegend(QLegend *legend, ChartTheme* theme) const;
                  void updateSeries(QAbstractSeries *series);
              public:
                  static QList<QGradient> generateSeriesGradients(const QList<QColor>& colors);
                  static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                  static QColor colorAt(const QGradient &gradient, qreal pos);
              private:
                  int createIndexKey(QList<int> keys) const;
                  int seriesCount(QAbstractSeries::SeriesType type) const;
              public Q_SLOTS:
                  void handleSeriesAdded(QAbstractSeries *series);
                  void handleSeriesRemoved(QAbstractSeries *series);
                  void handleAxisAdded(QAbstractAxis *axis);
                  void handleAxisRemoved(QAbstractAxis *axis);
              protected:
                  QScopedPointer<ChartTheme> m_theme;
                  QMap<QAbstractSeries *,int> m_seriesMap;
                  QList<QAbstractAxis *> m_axisList;
                  QChart* m_chart;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif // CHARTTHEME_H

src/linechart/qlineseries.cpp +3 -3

              /****************************************************************************
              **
              ** 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 "qlineseries.h"
              #include "qlineseries_p.h"
              #include "linechartitem_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
+             #include "qchart_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QLineSeries
                  \brief The QLineSeries class is used for making line charts.
                  \mainclass
                  A line chart is used to show information as a series of data points
                  connected by straight lines.
                  \image examples_linechart.png
                  Creating basic line chart is simple:
                  \code
                  QLineSeries* series = new QLineSeries();
                  series->append(0, 6);
                  series->append(2, 4);
                  ...
                  chart->addSeries(series);
                  \endcode
              */
              /*!
                  \qmlclass LineSeries QLineSeries
                  \inherits XYSeries
                  The following QML shows how to create a simple line chart:
                  \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
                  \beginfloatleft
                  \image demos_qmlchart2.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \fn virtual SeriesType QLineSeries::type() const
                  \brief Returns type of series.
                  \sa QAbstractSeries, SeriesType
              */
              /*!
                  \qmlproperty real LineSeries::width
                  The width of the line. By default the width is 2.0.
              */
              /*!
                  \qmlproperty Qt::PenStyle LineSeries::style
                  Controls the style of the line. Set to one of Qt.NoPen, Qt.SolidLine, Qt.DashLine, Qt.DotLine,
                  Qt.DashDotLine or Qt.DashDotDotLine. Using Qt.CustomDashLine is not supported in the QML API.
                  By default the style is Qt.SolidLine.
              */
              /*!
                  \qmlproperty Qt::PenCapStyle LineSeries::capStyle
                  Controls the cap style of the line. Set to one of Qt.FlatCap, Qt.SquareCap or Qt.RoundCap. By
                  default the cap style is Qt.SquareCap.
              */
              /*!
                  Constructs empty series object which is a child of \a parent.
                  When series object is added to QChartView or QChart instance ownerships is transferred.
              */
              QLineSeries::QLineSeries(QObject *parent)
                  : QXYSeries(*new QLineSeriesPrivate(this), parent)
              {
              }
              /*!
                  \internal
              */
              QLineSeries::QLineSeries(QLineSeriesPrivate &d, QObject *parent)
                  : QXYSeries(d, parent)
              {
              }
              /*!
                  Destroys the object. Series added to QChartView or QChart instances are owned by those,
                  and are deleted when mentioned object are destroyed.
              */
              QLineSeries::~QLineSeries()
              {
                  Q_D(QLineSeries);
                  if (d->m_chart)
                      d->m_chart->removeSeries(this);
              }
              QAbstractSeries::SeriesType QLineSeries::type() const
              {
                  return QAbstractSeries::SeriesTypeLine;
              }
              /*
              QDebug operator<< (QDebug debug, const QLineSeries series)
              {
                  Q_ASSERT(series.d_func()->m_x.size() == series.d_func()->m_y.size());
                  int size = series.d_func()->m_x.size();
                  for (int i=0; i<size; i++) {
                      debug.nospace() << "(" << series.d_func()->m_x.at(i) << ','<< series.d_func()->m_y.at(i) << ") ";
                  }
                  return debug.space();
              }
              */
              ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries *q)
                  : QXYSeriesPrivate(q)
              {
              };
              void QLineSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
              {
                  Q_Q(QLineSeries);
                  LineChartItem *line = new LineChartItem(q,parent);
                  m_item.reset(line);
                  QAbstractSeriesPrivate::initializeGraphics(parent);
              }
              void QLineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
              {
                  Q_Q(QLineSeries);
                  const QList<QColor> colors = theme->seriesColors();
-                 QPen pen;
-                 if (forced || pen == m_pen) {
+                 if (forced || QChartPrivate::defaultPen() == m_pen) {
+                     QPen pen;
                      pen.setColor(colors.at(index % colors.size()));
                      pen.setWidthF(2);
                      q->setPen(pen);
                  }
              }
              #include "moc_qlineseries.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +30 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 "qchart_p.h"
              #include "legendscroller_p.h"
              #include "qlegend_p.h"
              #include "chartbackground_p.h"
              #include "qabstractaxis.h"
              #include "abstractchartlayout_p.h"
              #include "charttheme_p.h"
              #include "chartpresenter_p.h"
              #include "chartdataset_p.h"
              #include <QGraphicsScene>
              #include <QGraphicsSceneResizeEvent>
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
               \enum QChart::ChartTheme
               This enum describes the theme used by the chart.
               \value ChartThemeLight The default theme
               \value ChartThemeBlueCerulean
               \value ChartThemeDark
               \value ChartThemeBrownSand
               \value ChartThemeBlueNcs
               \value ChartThemeHighContrast
               \value ChartThemeBlueIcy
               */
              /*!
               \enum QChart::AnimationOption
               For enabling/disabling animations. Defaults to NoAnimation.
               \value NoAnimation
               \value GridAxisAnimations
               \value SeriesAnimations
               \value AllAnimations
               */
              /*!
               \enum QChart::ChartType
               This enum describes the chart type.
               \value ChartTypeUndefined
               \value ChartTypeCartesian
               \value ChartTypePolar
               */
              /*!
               \class QChart
               \brief QtCommercial chart API.
               QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
               representation of different types of series and other chart related objects like legend and
               axes. If you simply want to show a chart in a layout, you can use the
               convenience class QChartView instead of QChart.
               \sa QChartView, QPolarChart
               */
              /*!
               \property QChart::animationOptions
               The animation \a options for the chart. Animations are enabled/disabled based on this setting.
               */
              /*!
               \property QChart::backgroundVisible
               Specifies whether the chart background is visible or not.
               \sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible
               */
              /*!
               \property QChart::dropShadowEnabled
               If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
               shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
               */
              /*!
               \property QChart::minimumMargins
               Minimum margins between the plot area (axes) and the edge of the chart widget.
               This property is deprecated; use margins property instead.
               \sa margins
               */
              /*!
               \property QChart::margins
               Margins between the plot area (axes) and the edge of the chart widget.
               */
              /*!
               \property QChart::theme
               Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
               pens, brushes, and fonts of series, axes, title, and legend. \l {Chart themes demo} shows an example with a few
               different themes.
               \note Changing the theme will overwrite all customizations previously applied to the series.
               */
              /*!
               \property QChart::title
               Title is the name (label) of a chart. It is shown as a headline on top of the chart.
               */
              /*!
               \property QChart::chartType
               Chart type indicates if the chart is a cartesian chart or a polar chart.
               This property is set internally and it is read only.
               \sa QPolarChart
               */
              /*!
               \property QChart::plotAreaBackgroundVisible
               Specifies whether the chart plot area background is visible or not.
               \note By default the plot area background is not visible and the plot area uses
               the general chart background.
               \sa setPlotAreaBackgroundBrush(), setPlotAreaBackgroundPen(), backgroundVisible
               */
              /*!
               \internal
               Constructs a chart object of \a type which is a child of a \a parent.
               Parameter \a wFlags is passed to the QGraphicsWidget constructor.
               This constructor is called only by subclasses.
              */
              QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
                  : QGraphicsWidget(parent, wFlags),
                    d_ptr(new QChartPrivate(this, type))
              {
                  d_ptr->init();
              }
              /*!
               Constructs a chart object which is a child of a \a parent.
               Parameter \a wFlags is passed to the QGraphicsWidget constructor.
               */
              QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                  : QGraphicsWidget(parent, wFlags),
                    d_ptr(new QChartPrivate(this, ChartTypeCartesian))
              {
                  d_ptr->init();
              }
              /*!
               Destroys the chart object and its children, like series and axis objects added to it.
               */
              QChart::~QChart()
              {
                  //start by deleting dataset, it will remove all series and axes
                  delete d_ptr->m_dataset;
                  d_ptr->m_dataset = 0;
              }
              /*!
               Adds the \a series onto the chart and takes the ownership of it.
               \note A newly added series is attached to no axes by default, including any axes that were created for the chart
               using createDefaultAxes() before the series was added to the chart. If no axes are attached to
               the newly added series before the chart is shown, the series will get drawn as if it had axes with ranges
               that exactly fit the series to the plot area of the chart. This can be confusing if the same chart also displays other
               series that have properly attached axes, so always make sure you either call createDefaultAxes() after
               a series has been added or explicitly attach axes for the series.
               \sa removeSeries(), removeAllSeries(), createDefaultAxes(), QAbstractSeries::attachAxis()
               */
              void QChart::addSeries(QAbstractSeries *series)
              {
                  Q_ASSERT(series);
                  d_ptr->m_dataset->addSeries(series);
              }
              /*!
               Removes the \a series from the chart.
               The chart releases its ownership of the specified \a series object.
               \sa addSeries(), removeAllSeries()
               */
              void QChart::removeSeries(QAbstractSeries *series)
              {
                  Q_ASSERT(series);
                  d_ptr->m_dataset->removeSeries(series);
              }
              /*!
               Removes and deletes all series objects that have been added to the chart.
               \sa addSeries(), removeSeries()
               */
              void QChart::removeAllSeries()
              {
                  foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                      removeSeries(s);
                      delete s;
                  }
              }
              /*!
               Sets the \a brush that is used for painting the background of the chart area.
               */
              void QChart::setBackgroundBrush(const QBrush &brush)
              {
                  d_ptr->m_presenter->setBackgroundBrush(brush);
              }
              /*!
               Gets the brush that is used for painting the background of the chart area.
               */
              QBrush QChart::backgroundBrush() const
              {
                  return d_ptr->m_presenter->backgroundBrush();
              }
              /*!
               Sets the \a pen that is used for painting the background of the chart area.
               */
              void QChart::setBackgroundPen(const QPen &pen)
              {
                  d_ptr->m_presenter->setBackgroundPen(pen);
              }
              /*!
               Gets the pen that is used for painting the background of the chart area.
               */
              QPen QChart::backgroundPen() const
              {
                  return d_ptr->m_presenter->backgroundPen();
              }
              void QChart::setTitle(const QString &title)
              {
                  d_ptr->m_presenter->setTitle(title);
              }
              QString QChart::title() const
              {
                  return d_ptr->m_presenter->title();
              }
              /*!
               Sets the \a font that is used for drawing the chart title.
               */
              void QChart::setTitleFont(const QFont &font)
              {
                  d_ptr->m_presenter->setTitleFont(font);
              }
              /*!
               Gets the font that is used for drawing the chart title.
               */
              QFont QChart::titleFont() const
              {
                  return d_ptr->m_presenter->titleFont();
              }
              /*!
               Sets the \a brush used for drawing the title text.
               */
              void QChart::setTitleBrush(const QBrush &brush)
              {
                  d_ptr->m_presenter->setTitleBrush(brush);
              }
              /*!
               Returns the brush used for drawing the title text.
               */
              QBrush QChart::titleBrush() const
              {
                  return d_ptr->m_presenter->titleBrush();
              }
              void QChart::setTheme(QChart::ChartTheme theme)
              {
                  d_ptr->m_themeManager->setTheme(theme);
              }
              QChart::ChartTheme QChart::theme() const
              {
                  return d_ptr->m_themeManager->theme()->id();
              }
              /*!
               Zooms in the view by a factor of two.
               */
              void QChart::zoomIn()
              {
                  d_ptr->zoomIn(2.0);
              }
              /*!
               Zooms in the view to a maximum level at which \a rect is still fully visible.
               \note This is not supported for polar charts.
               */
              void QChart::zoomIn(const QRectF &rect)
              {
                  if (d_ptr->m_type == QChart::ChartTypePolar)
                      return;
                  d_ptr->zoomIn(rect);
              }
              /*!
               Zooms out the view by a factor of two.
               */
              void QChart::zoomOut()
              {
                  d_ptr->zoomOut(2.0);
              }
              /*!
               Zooms in the view by a custom \a factor.
               A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
               */
              void QChart::zoom(qreal factor)
              {
                  if (qFuzzyCompare(factor, 0))
                      return;
                  if (qFuzzyCompare(factor, (qreal)1.0))
                      return;
                  if (factor < 0)
                      return;
                  if (factor > 1.0)
                      d_ptr->zoomIn(factor);
                  else
                      d_ptr->zoomOut(1.0 / factor);
              }
              /*!
               Returns a pointer to the horizontal axis attached to the specified \a series.
               If no \a series is specified, the first horizontal axis added to the chart is returned.
               \sa addAxis(), QAbstractSeries::attachAxis()
               */
              QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
              {
                  QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                  if (axisList.count())
                      return axisList[0];
                  return 0;
              }
              /*!
               Returns a pointer to the vertical axis attached to the specified \a series.
               If no \a series is specified, the first vertical axis added to the chart is returned.
               \sa addAxis(), QAbstractSeries::attachAxis()
               */
              QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
              {
                  QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                  if (axisList.count())
                      return axisList[0];
                  return 0;
              }
              /*!
               Returns the axes attached to the \a series with \a orientation. If no \a series is provided,
               then all axes added to the chart with the specified orientation are returned.
               \sa addAxis(), createDefaultAxes()
               */
              QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
              {
                  QList<QAbstractAxis *> result ;
                  if (series) {
                      foreach (QAbstractAxis *axis, series->attachedAxes()){
                          if (orientation.testFlag(axis->orientation()))
                              result << axis;
                      }
                  } else {
                      foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                          if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                              result << axis;
                      }
                  }
                  return result;
              }
              /*!
               Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to
               the chart will be deleted.
               \note This function has to be called after all series have been added to the chart. The axes created by this function
               will NOT get automatically attached to any series added to the chart after this function has been called.
               A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing
               if there are other series with properly attached axes also present.
               \table
                   \header
                       \o Series type
                       \o X-axis
                       \o Y-axis
                   \row
                       \o QXYSeries
                       \o QValueAxis
                       \o QValueAxis
                   \row
                       \o QBarSeries
                       \o QBarCategoryAxis
                       \o QValueAxis
                   \row
                       \o QPieSeries
                       \o None
                       \o None
               \endtable
               If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created.
               If there are several series of different types added to the chart, then each series gets its own axes pair.
               The axes specific to the series can be later obtained from the chart by providing the series as the parameter for axes() function call.
               QPieSeries does not create any axes.
               \sa axisX(), axisY(), axes(), setAxisX(), setAxisY(), QAbstractSeries::attachAxis()
               */
              void QChart::createDefaultAxes()
              {
                  d_ptr->m_dataset->createDefaultAxes();
              }
              /*!
               Returns the legend object of the chart. Ownership stays with the chart.
               */
              QLegend *QChart::legend() const
              {
                  return d_ptr->m_legend;
              }
              void QChart::setMinimumMargins(const QMargins &margins)
              {
                  qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                  d_ptr->m_presenter->layout()->setMargins(margins);
              }
              QMargins QChart::minimumMargins() const
              {
                  qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                  return d_ptr->m_presenter->layout()->margins();
              }
              void QChart::setMargins(const QMargins &margins)
              {
                  d_ptr->m_presenter->layout()->setMargins(margins);
              }
              QMargins QChart::margins() const
              {
                  return d_ptr->m_presenter->layout()->margins();
              }
              QChart::ChartType QChart::chartType() const
              {
                  return d_ptr->m_type;
              }
              /*!
                  Returns the the rectangle within which the drawing of the chart is done.
                  It does not include the area defined by margins.
               */
              QRectF QChart::plotArea() const
              {
                  return d_ptr->m_presenter->geometry();
              }
              /*!
                  Sets the \a brush for the background of the plot area of the chart.
                  \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundPen(), plotAreaBackgroundBrush()
               */
              void QChart::setPlotAreaBackgroundBrush(const QBrush &brush)
              {
                  d_ptr->m_presenter->setPlotAreaBackgroundBrush(brush);
              }
              /*!
                  Returns the brush for the background of the plot area of the chart.
                  \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundPen(), setPlotAreaBackgroundBrush()
               */
              QBrush QChart::plotAreaBackgroundBrush() const
              {
                  return d_ptr->m_presenter->plotAreaBackgroundBrush();
              }
              /*!
                  Sets the \a pen for the background of the plot area of the chart.
                  \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundBrush(), plotAreaBackgroundPen()
               */
              void QChart::setPlotAreaBackgroundPen(const QPen &pen)
              {
                  d_ptr->m_presenter->setPlotAreaBackgroundPen(pen);
              }
              /*!
                  Returns the 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_legend(0),
                  m_dataset(new ChartDataSet(q)),
                  m_presenter(new ChartPresenter(q, type)),
                  m_themeManager(new ChartThemeManager(q)),
                  m_type(type)
              {
                  QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                  QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                  QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                  QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                  QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                  QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                  QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                  QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
              }
              QChartPrivate::~QChartPrivate()
              {
              }
+             // Hackish solution to the problem of explicitly assigning the default pen/brush/font
+             // to a series or axis and having theme override it:
+             // Initialize pens, brushes, and fonts to something nobody is likely to ever use,
+             // so that default theme initialization will always set these properly.
+             QPen &QChartPrivate::defaultPen()
+             {
+                 static QPen *defaultPen = 0;
+                 if (!defaultPen)
+                     defaultPen = new QPen(QColor(1, 2, 0), 0.93247536);
+                 return *defaultPen;
+             }
+             QBrush &QChartPrivate::defaultBrush()
+             {
+                 static QBrush *defaultBrush = 0;
+                 if (!defaultBrush)
+                     defaultBrush = new QBrush(QColor(1, 2, 0), Qt::Dense7Pattern);
+                 return *defaultBrush;
+             }
+             QFont &QChartPrivate::defaultFont()
+             {
+                 static QFont *defaultFont = 0;
+                 if (!defaultFont) {
+                     defaultFont = new QFont();
+                     defaultFont->setPointSizeF(8.34563465);
+                 }
+                 return *defaultFont;
+             }
              void QChartPrivate::init()
              {
                  m_legend = new LegendScroller(q_ptr);
                  q_ptr->setTheme(QChart::ChartThemeLight);
                  q_ptr->setLayout(m_presenter->layout());
              }
              void QChartPrivate::zoomIn(qreal factor)
              {
                  QRectF rect = m_presenter->geometry();
                  rect.setWidth(rect.width() / factor);
                  rect.setHeight(rect.height() / factor);
                  rect.moveCenter(m_presenter->geometry().center());
                  zoomIn(rect);
              }
              void QChartPrivate::zoomIn(const QRectF &rect)
              {
                  if (!rect.isValid())
                      return;
                  QRectF r = rect.normalized();
                  const QRectF geometry = m_presenter->geometry();
                  r.translate(-geometry.topLeft());
                  if (!r.isValid())
                      return;
                  QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                  m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                  m_dataset->zoomInDomain(r);
                  m_presenter->setState(ChartPresenter::ShowState,QPointF());
              }
              void QChartPrivate::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_p.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$
              **
              ****************************************************************************/
              //  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 QCHART_P_H
              #define QCHART_P_H
              #include "qchartglobal.h"
              #include "qchart.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class ChartThemeManager;
              class ChartPresenter;
              class QLegend;
              class ChartDataSet;
              class QChartPrivate
              {
              public:
                  QChartPrivate(QChart *q, QChart::ChartType type);
                  ~QChartPrivate();
                  QChart *q_ptr;
                  QLegend *m_legend;
                  ChartDataSet *m_dataset;
                  ChartPresenter *m_presenter;
                  ChartThemeManager *m_themeManager;
                  QChart::ChartType m_type;
+                 static QPen &defaultPen();
+                 static QBrush &defaultBrush();
+                 static QFont &defaultFont();
                  void init();
                  void zoomIn(qreal factor);
                  void zoomOut(qreal factor);
                  void zoomIn(const QRectF &rect);
                  void scroll(qreal dx, qreal dy);
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif

src/scatterchart/qscatterseries.cpp +4 -4

              /****************************************************************************
              **
              ** 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 "qscatterseries.h"
              #include "qscatterseries_p.h"
              #include "scatterchartitem_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "scatteranimation_p.h"
+             #include "qchart_p.h"
              /*!
                  \class QScatterSeries
                  \brief The QScatterSeries class is used for making scatter charts.
                  \mainclass
                  The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                  and the vertical axis.
                  \image examples_scatterchart.png
                  Creating basic scatter chart is simple:
                  \code
                  QScatterSeries* series = new QScatterSeries();
                  series->append(0, 6);
                  series->append(2, 4);
                  ...
                  chart->addSeries(series);
                  \endcode
              */
              /*!
                  \qmlclass ScatterSeries QScatterSeries
                  \inherits XYSeries
                  The following QML shows how to create a chart with two simple scatter series:
                  \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
                  \beginfloatleft
                  \image demos_qmlchart5.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \enum QScatterSeries::MarkerShape
                  This enum describes the shape used when rendering marker items.
                  \value MarkerShapeCircle
                  \value MarkerShapeRectangle
              */
              /*!
                  \property QScatterSeries::color
                  Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                  \sa QScatterSeries::brush()
              */
              /*!
                  \property QScatterSeries::borderColor
                  Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                  \sa QScatterSeries::pen()
              */
              /*!
                  \qmlproperty color ScatterSeries::borderColor
                  Border (pen) color of the series.
              */
              /*!
                  \qmlproperty real ScatterSeries::borderWidth
                  The width of the border line. By default the width is 2.0.
              */
              /*!
                  \property QScatterSeries::markerShape
                  Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
              */
              /*!
                  \qmlproperty MarkerShape ScatterSeries::markerShape
                  Defines the shape of the marker used to draw the points in the series. One of ScatterSeries
                  ScatterSeries.MarkerShapeCircle or ScatterSeries.MarkerShapeRectangle.
                  The default shape is ScatterSeries.MarkerShapeCircle.
              */
              /*!
                  \property QScatterSeries::markerSize
                  Defines the size of the marker used to draw the points in the series. The default size is 15.0.
              */
              /*!
                  \qmlproperty real ScatterSeries::markerSize
                  Defines the size of the marker used to draw the points in the series. The default size is 15.0.
              */
              /*!
                  \fn void QScatterSeries::colorChanged(QColor color)
                  Signal is emitted when the fill (brush) color has changed to \a color.
              */
              /*!
                  \fn void QScatterSeries::borderColorChanged(QColor color)
                  Signal is emitted when the line (pen) color has changed to \a color.
              */
              /*!
                  \qmlsignal ScatterSeries::borderColorChanged(color color)
                  Signal is emitted when the line (pen) color has changed to \a color.
              */
              /*!
                  \fn QChartSeriesType QScatterSeries::type() const
                  Returns QChartSeries::SeriesTypeScatter.
                  \sa QAbstractSeries, SeriesType
              */
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  Constructs a series object which is a child of \a parent.
              */
              QScatterSeries::QScatterSeries(QObject *parent)
                  : QXYSeries(*new QScatterSeriesPrivate(this), parent)
              {
              }
              /*!
                  Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
              */
              QScatterSeries::~QScatterSeries()
              {
                  Q_D(QScatterSeries);
                  if (d->m_chart)
                      d->m_chart->removeSeries(this);
              }
              QAbstractSeries::SeriesType QScatterSeries::type() const
              {
                  return QAbstractSeries::SeriesTypeScatter;
              }
              /*!
                  Sets \a pen used for drawing points' border on the chart. If the pen is not defined, the
                  pen from chart theme is used.
                  \sa QChart::setTheme()
              */
              void QScatterSeries::setPen(const QPen &pen)
              {
                  Q_D(QXYSeries);
                  if (d->m_pen != pen) {
                      bool emitColorChanged = d->m_pen.color() != pen.color();
                      d->m_pen = pen;
                      emit d->updated();
                      if (emitColorChanged)
                          emit borderColorChanged(pen.color());
                  }
              }
              /*!
                  Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                  from chart theme setting is used.
                  \sa QChart::setTheme()
              */
              void QScatterSeries::setBrush(const QBrush &brush)
              {
                  Q_D(QScatterSeries);
                  if (d->m_brush != brush) {
                      bool emitColorChanged = d->m_brush.color() != brush.color();
                      d->m_brush = brush;
                      emit d->updated();
                      if (emitColorChanged)
                          emit colorChanged(brush.color());
                  }
              }
              void QScatterSeries::setColor(const QColor &color)
              {
                  QBrush b = brush();
                  if (b == QBrush())
                      b.setStyle(Qt::SolidPattern);
                  b.setColor(color);
                  setBrush(b);
              }
              QColor QScatterSeries::color() const
              {
                  return brush().color();
              }
              void QScatterSeries::setBorderColor(const QColor &color)
              {
                  QPen p = pen();
                  if (p.color() != color) {
                      p.setColor(color);
                      setPen(p);
                  }
              }
              QColor QScatterSeries::borderColor() const
              {
                  return pen().color();
              }
              QScatterSeries::MarkerShape QScatterSeries::markerShape() const
              {
                  Q_D(const QScatterSeries);
                  return d->m_shape;
              }
              void QScatterSeries::setMarkerShape(MarkerShape shape)
              {
                  Q_D(QScatterSeries);
                  if (d->m_shape != shape) {
                      d->m_shape = shape;
                      emit d->updated();
                  }
              }
              qreal QScatterSeries::markerSize() const
              {
                  Q_D(const QScatterSeries);
                  return d->m_size;
              }
              void QScatterSeries::setMarkerSize(qreal size)
              {
                  Q_D(QScatterSeries);
                  if (!qFuzzyCompare(d->m_size, size)) {
                      d->m_size = size;
                      emit d->updated();
                  }
              }
              ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q)
                  : QXYSeriesPrivate(q),
                    m_shape(QScatterSeries::MarkerShapeCircle),
                    m_size(15.0)
              {
              }
              void QScatterSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
              {
                  Q_Q(QScatterSeries);
                  ScatterChartItem *scatter = new ScatterChartItem(q,parent);
                  m_item.reset(scatter);
                  QAbstractSeriesPrivate::initializeGraphics(parent);
              }
              void QScatterSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
              {
                  Q_Q(QScatterSeries);
-                 QPen pen;
-                 QBrush brush;
                  const QList<QColor> colors = theme->seriesColors();
                  const QList<QGradient> gradients = theme->seriesGradients();
-                 if (forced || pen == m_pen) {
+                 if (forced || QChartPrivate::defaultPen() == m_pen) {
+                     QPen pen;
                      pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                      pen.setWidthF(2);
                      q->setPen(pen);
                  }
-                 if (forced || brush == m_brush) {
+                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                      QBrush brush(colors.at(index % colors.size()));
                      q->setBrush(brush);
                  }
              }
              void QScatterSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
              {
                  ScatterChartItem *item = static_cast<ScatterChartItem *>(m_item.data());
                  Q_ASSERT(item);
                  if (options.testFlag(QChart::SeriesAnimations))
                      item->setAnimation(new ScatterAnimation(item));
                  else
                      item->setAnimation(0);
                  QAbstractSeriesPrivate::initializeAnimations(options);
              }
              #include "moc_qscatterseries.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +3 -2

              /****************************************************************************
              **
              ** 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 "qsplineseries.h"
              #include "qsplineseries_p.h"
              #include "splinechartitem_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "splineanimation_p.h"
+             #include "qchart_p.h"
              /*!
                  \class QSplineSeries
                  \brief Series type used to store data needed to draw a spline.
                  QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                  Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                  \image examples_splinechart.png
                  Creating basic spline chart is simple:
                  \code
                  QSplineSeries* series = new QSplineSeries();
                  series->append(0, 6);
                  series->append(2, 4);
                  ...
                  chart->addSeries(series);
                  \endcode
              */
              /*!
                  \qmlclass SplineSeries QSplineSeries
                  \inherits XYSeries
                  The following QML shows how to create a simple spline chart:
                  \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
                  \beginfloatleft
                  \image demos_qmlchart3.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \fn QSeriesType QSplineSeries::type() const
                  Returns the type of the series
              */
              /*!
                  \qmlproperty real SplineSeries::width
                  The width of the line. By default the width is 2.0.
              */
              /*!
                  \qmlproperty Qt::PenStyle SplineSeries::style
                  Controls the style of the line. Set to one of Qt.NoPen, Qt.SolidLine, Qt.DashLine, Qt.DotLine,
                  Qt.DashDotLine or Qt.DashDotDotLine. Using Qt.CustomDashLine is not supported in the QML API.
                  By default the style is Qt.SolidLine.
              */
              /*!
                  \qmlproperty Qt::PenCapStyle SplineSeries::capStyle
                  Controls the cap style of the line. Set to one of Qt.FlatCap, Qt.SquareCap or Qt.RoundCap. By
                  default the cap style is Qt.SquareCap.
              */
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  Constructs empty series object which is a child of \a parent.
                  When series object is added to a QChart instance then the ownerships is transferred.
                */
              QSplineSeries::QSplineSeries(QObject *parent)
                  : QLineSeries(*new QSplineSeriesPrivate(this), parent)
              {
              }
              /*!
                Destroys the object.
              */
              QSplineSeries::~QSplineSeries()
              {
                  Q_D(QSplineSeries);
                  if (d->m_chart)
                      d->m_chart->removeSeries(this);
              }
              QAbstractSeries::SeriesType QSplineSeries::type() const
              {
                  return QAbstractSeries::SeriesTypeSpline;
              }
              ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries *q)
                  : QLineSeriesPrivate(q)
              {
              }
              void QSplineSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
              {
                  Q_Q(QSplineSeries);
                  SplineChartItem *spline = new SplineChartItem(q,parent);
                  m_item.reset(spline);
                  QAbstractSeriesPrivate::initializeGraphics(parent);
              }
              void QSplineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
              {
                  Q_Q(QSplineSeries);
                  const QList<QColor> colors = theme->seriesColors();
-                 QPen pen;
-                 if (forced || pen == m_pen) {
+                 if (forced || QChartPrivate::defaultPen() == m_pen) {
+                     QPen pen;
                      pen.setColor(colors.at(index % colors.size()));
                      pen.setWidthF(2);
                      q->setPen(pen);
                  }
              }
              void QSplineSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
              {
                  SplineChartItem *item = static_cast<SplineChartItem *>(m_item.data());
                  Q_ASSERT(item);
                  if (options.testFlag(QChart::SeriesAnimations)) {
                      item->setAnimation(new SplineAnimation(item));
                  }else{
                      item->setAnimation(0);
                  }
                  QAbstractSeriesPrivate::initializeAnimations(options);
              }
              #include "moc_qsplineseries.cpp"
              #include "moc_qsplineseries_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/themes/charttheme_p.h +4 -2

              /****************************************************************************
              **
              ** 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 CHARTTHEME_H
              #define CHARTTHEME_H
              #include "chartthememanager_p.h"
              #include <QColor>
              #include <QGradientStops>
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class ChartTheme
              {
              public:
                  enum BackgroundShadesMode {
                      BackgroundShadesNone = 0,
                      BackgroundShadesVertical,
                      BackgroundShadesHorizontal,
                      BackgroundShadesBoth
                  };
              protected:
                  explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight):m_id(id),
-                 m_backgroundShades(BackgroundShadesNone),
-                 m_backgroundDropShadowEnabled(false){};
+                     m_backgroundShades(BackgroundShadesNone),
+                     m_backgroundShadesBrush(Qt::SolidPattern),
+                     m_backgroundDropShadowEnabled(false)
+                 {};
              public:
                  QChart::ChartTheme id() const { return m_id; }
                  QList<QGradient> seriesGradients() const { return m_seriesGradients; }
                  QList<QColor> seriesColors() const { return m_seriesColors; }
                  QLinearGradient chartBackgroundGradient() const { return m_chartBackgroundGradient; }
                  QFont masterFont() const { return m_masterFont; }
                  QFont labelFont() const { return m_labelFont; }
                  QBrush labelBrush() const { return m_labelBrush; }
                  QPen axisLinePen() const { return m_axisLinePen; }
                  QPen backgroundShadesPen() const { return m_backgroundShadesPen; }
                  QBrush backgroundShadesBrush() const { return m_backgroundShadesBrush; }
                  BackgroundShadesMode backgroundShades() const { return m_backgroundShades; }
                  bool isBackgroundDropShadowEnabled() const { return m_backgroundDropShadowEnabled; }
                  QPen girdLinePen() const { return m_gridLinePen; }
              protected:
                  QChart::ChartTheme m_id;
                  QList<QColor> m_seriesColors;
                  QList<QGradient> m_seriesGradients;
                  QLinearGradient m_chartBackgroundGradient;
                  QFont m_masterFont;
                  QFont m_labelFont;
                  QBrush m_labelBrush;
                  QPen m_axisLinePen;
                  QPen m_backgroundShadesPen;
                  QBrush m_backgroundShadesBrush;
                  BackgroundShadesMode m_backgroundShades;
                  bool m_backgroundDropShadowEnabled;
                  QPen m_gridLinePen;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif // CHARTTHEME_H

src/xychart/qxyseries.cpp +3 0

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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