HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2522:e2eb16a7c3b1

Fix android build issues...

Heikkinen Miikka -

r2522:e2eb16a7c3b1

parent child

Context file:

r2522:e2eb16a7c3b1

Collapse all files

src/axis/qabstractaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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 linePen().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
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_labelsPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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 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
             {
                 if (d_ptr->m_titlePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     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 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 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(QChartPrivate::defaultBrush()),
                   m_shadesPen(QChartPrivate::defaultPen()),
+                  m_shadesBrush(QChartPrivate::defaultBrush()),
                   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)
             {
                 //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);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 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/chartconfig_p.h +5 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 CHARTCONFIG_H
             #define CHARTCONFIG_H
             #include "qchartglobal.h"
             #ifdef Q_CC_MSVC
             // There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
             // This is the case at least with shadow builds.
             // http://qt-project.org/wiki/jom
             #undef DEVELOPMENT_BUILD
             #endif
             #ifndef DEVELOPMENT_BUILD
+            #ifdef Q_OS_ANDROID
+            // Android builds do not have __DATE__
+            const char *buildTime =  __TIME__;
+            #else
             const char *buildTime =  __TIME__" "__DATE__;
+            #endif
             const char *gitHead = "unknown";
             #else
             #include "qchartversion_p.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartConfig
             {
             private:
                 ChartConfig() {
             #if defined(DEVELOPMENT_BUILD) && !defined(QT_NO_DEBUG)
                     qDebug() << "buildTime" << buildTime;
                     qDebug() << "gitHead" << gitHead;
             #endif
                     m_instance = this;
                 }
             public:
                 static ChartConfig *instance() {
                     if (!m_instance) {
                         m_instance = new ChartConfig();
                     }
                     return m_instance;
                 }
                 QString compilationTime() {
                     return QString(buildTime);
                 }
                 QString compilationHead() {
                     return QString(gitHead);
                 }
             private:
                 static ChartConfig *m_instance;
             };
             ChartConfig *ChartConfig::m_instance = 0;
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/themes/charttheme_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  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_backgroundShadesBrush(Qt::SolidPattern),
+                    m_backgroundShades(BackgroundShadesNone),
                     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

tests/polarcharttest/mainwindow.cpp +7 -7

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

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