HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2810:2db41b8cb90b

Added grid color property for value axis...

Titta Heikkala -

r2810:2db41b8cb90b

parent child

Context file:

r2810:2db41b8cb90b

Collapse all files

src/charts/axis/cartesianchartaxis.cpp +20 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/cartesianchartaxis_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/linearrowitem_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtWidgets/QGraphicsLayout>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             CartesianChartAxis::CartesianChartAxis(QAbstractAxis *axis, QGraphicsItem *item , bool intervalAxis)
                 : ChartAxisElement(axis, item, intervalAxis)
             {
                 Q_ASSERT(item);
             }
             CartesianChartAxis::~CartesianChartAxis()
             {
             }
             void CartesianChartAxis::createItems(int count)
             {
                 if (arrowItems().size() == 0) {
                     QGraphicsLineItem *arrow = new LineArrowItem(this, this);
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 if (intervalAxis() && gridItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem *item = new QGraphicsLineItem(this);
                         item->setPen(axis()->gridLinePen());
                         gridGroup()->addToGroup(item);
                         QGraphicsRectItem *shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
                 QGraphicsTextItem *title = titleItem();
                 title->setFont(axis()->titleFont());
                 title->setDefaultTextColor(axis()->titleBrush().color());
                 title->setHtml(axis()->titleText());
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(this);
                     QGraphicsLineItem *grid = new QGraphicsLineItem(this);
                     QGraphicsTextItem *label = new QGraphicsTextItem(this);
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsRectItem *shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
             }
             void CartesianChartAxis::updateMinorTickItems()
             {
                 QValueAxis *valueAxis = qobject_cast<QValueAxis *>(this->axis());
                 if (valueAxis) {
                     int currentCount = minorArrowItems().size();
                     int expectedCount = valueAxis->minorTickCount() * (valueAxis->tickCount() - 1);
                     int diff = expectedCount - currentCount;
                     if (diff > 0) {
                         for (int i = 0; i < diff; i++) {
                             QGraphicsLineItem *minorArrow = new QGraphicsLineItem(this);
                             QGraphicsLineItem *minorGrid = new QGraphicsLineItem(this);
                             minorArrow->setPen(valueAxis->linePen());
                             minorGrid->setPen(valueAxis->minorGridLinePen());
                             minorArrowGroup()->addToGroup(minorArrow);
                             minorGridGroup()->addToGroup(minorGrid);
                         }
                     } else {
                         QList<QGraphicsItem *> minorGridLines = minorGridItems();
                         QList<QGraphicsItem *> minorArrows = minorArrowItems();
                         for (int i = 0; i > diff; i--) {
                             if (!minorGridLines.isEmpty())
                                 delete(minorGridLines.takeLast());
                             if (!minorArrows.isEmpty())
                                 delete(minorArrows.takeLast());
                         }
                     }
                 }
             }
             void CartesianChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() == 1 || (((lines.size() + 1) % 2) && lines.size() > 0))
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void CartesianChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = ChartAxisElement::layout().size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 updateMinorTickItems();
                 if (animation()) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         animation()->setAnimationType(AxisAnimation::ZoomInAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         animation()->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         animation()->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         animation()->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         animation()->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     animation()->setValues(ChartAxisElement::layout(), layout);
                     presenter()->startAnimation(animation());
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             bool CartesianChartAxis::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             void CartesianChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 setAxisGeometry(axis);
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             QSizeF CartesianChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             void CartesianChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleMinorArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorArrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleMinorGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorGridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
+            void CartesianChartAxis::handleGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, gridItems()) {
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
+                    QPen pen = lineItem->pen();
+                    pen.setColor(color);
+                    lineItem->setPen(pen);
+                }
+            }
+            void CartesianChartAxis::handleMinorGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, minorGridItems()) {
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
+                    QPen pen = lineItem->pen();
+                    pen.setColor(color);
+                    lineItem->setPen(pen);
+                }
+            }
             void CartesianChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void CartesianChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             #include "moc_cartesianchartaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/cartesianchartaxis_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CARTESIANCHARTAXIS_H
             #define CARTESIANCHARTAXIS_H
             #include <QtCharts/QChartGlobal>
             #include <private/chartaxiselement_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxis;
             class CartesianChartAxis : public ChartAxisElement
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 CartesianChartAxis(QAbstractAxis *axis, QGraphicsItem *item = 0, bool intervalAxis = false);
                 ~CartesianChartAxis();
                 void setGeometry(const QRectF &axis, const QRectF &grid);
                 QRectF gridGeometry() const { return m_gridRect; }
                 bool isEmpty();
                 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
             protected:
                 void setGeometry(const QRectF &size) { Q_UNUSED(size);}
                 virtual void updateGeometry() = 0;
                 void updateLayout(QVector<qreal> &layout);
             public Q_SLOTS:
                 virtual void handleArrowPenChanged(const QPen &pen);
                 virtual void handleGridPenChanged(const QPen &pen);
                 virtual void handleShadesBrushChanged(const QBrush &brush);
                 virtual void handleShadesPenChanged(const QPen &pen);
                 virtual void handleMinorArrowPenChanged(const QPen &pen);
                 virtual void handleMinorGridPenChanged(const QPen &pen);
+                virtual void handleGridLineColorChanged(const QColor &color);
+                virtual void handleMinorGridLineColorChanged(const QColor &color);
             private:
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateMinorTickItems();
             private:
                 QRectF m_gridRect;
                 friend class AxisAnimation;
                 friend class LineArrowItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CARTESIANCHARTAXIS_H */

src/charts/axis/chartaxiselement.cpp +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/chartaxiselement_p.h>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtCore/QtMath>
             #include <QtCore/QDateTime>
             #include <QtGui/QTextDocument>
             #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             static const char *labelFormatMatchString = "%[\\-\\+#\\s\\d\\.\\'lhjztL]*([dicuoxfegXFEG])";
             static const char *labelFormatMatchLocalizedString = "^([^%]*)%\\.(\\d+)([defgiEG])(.*)$";
             static QRegExp *labelFormatMatcher = 0;
             static QRegExp *labelFormatMatcherLocalized = 0;
             class StaticLabelFormatMatcherDeleter
             {
             public:
                 StaticLabelFormatMatcherDeleter() {}
                 ~StaticLabelFormatMatcherDeleter() {
                     delete labelFormatMatcher;
                     delete labelFormatMatcherLocalized;
                 }
             };
             static StaticLabelFormatMatcherDeleter staticLabelFormatMatcherDeleter;
             ChartAxisElement::ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_animation(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_minorGrid(new QGraphicsItemGroup(item)),
                   m_minorArrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsTextItem(item)),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_minorArrow->setHandlesChildEvents(false);
                 m_minorArrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_minorGrid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 m_title->document()->setDocumentMargin(ChartPresenter::textMargin());
                 handleVisibleChanged(axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents, true);
             }
             ChartAxisElement::~ChartAxisElement()
             {
             }
             void ChartAxisElement::connectSlots()
             {
                 QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
                 QObject::connect(axis(), SIGNAL(reverseChanged(bool)), this, SLOT(handleReverseChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)),
                                  this, SLOT(handleMinorArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this,
                                  SLOT(handleMinorArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(minorGridVisibleChanged(bool)),
                                  this, SLOT(handleMinorGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(minorGridLinePenChanged(const QPen&)),
                                  this, SLOT(handleMinorGridPenChanged(const QPen&)));
+                QObject::connect(axis(), SIGNAL(gridLineColorChanged(const QColor&)),
+                                 this, SLOT(handleGridLineColorChanged(const QColor&)));
+                QObject::connect(axis(), SIGNAL(minorGridLineColorChanged(const QColor&)),
+                                 this, SLOT(handleMinorGridLineColorChanged(const QColor&)));
                 if (axis()->type() == QAbstractAxis::AxisTypeCategory) {
                     QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                     QObject::connect(categoryAxis,
                                      SIGNAL(labelsPositionChanged(QCategoryAxis::AxisLabelsPosition)),
                                      this, SLOT(handleLabelsPositionChanged()));
                 }
             }
             void ChartAxisElement::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxisElement::handleMinorArrowVisibleChanged(bool visible)
             {
                 m_minorArrow->setVisible(visible);
             }
             void ChartAxisElement::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxisElement::handleMinorGridVisibleChanged(bool visible)
             {
                 m_minorGrid->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsPositionChanged()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_labels->setVisible(visible);
             }
             void ChartAxisElement::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxisElement::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 if (title.isEmpty() || !m_title->isVisible())
                     m_title->setHtml(title);
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleTitleFontChanged(const QFont &font)
             {
                 if (m_title->font() != font) {
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxisElement::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if (!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_minorGrid->setVisible(visible);
                     m_minorArrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 } else {
                     m_grid->setVisible(axis()->isGridLineVisible());
                     m_arrow->setVisible(axis()->isLineVisible());
                     m_minorGrid->setVisible(axis()->isMinorGridLineVisible());
                     m_minorArrow->setVisible(axis()->isLineVisible());
                     m_shades->setVisible(axis()->shadesVisible());
                     m_labels->setVisible(axis()->labelsVisible());
                     m_title->setVisible(axis()->isTitleVisible());
                 }
                 if (presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         // We don't want to call invalidate on layout, since it will change minimum size of
                         // component, which we would like to avoid since it causes nasty flips when scrolling
                         // or zooming, instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             void ChartAxisElement::handleReverseChanged(bool reverse)
             {
                 Q_UNUSED(reverse);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             bool ChartAxisElement::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             qreal ChartAxisElement::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxisElement::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QString ChartAxisElement::formatLabel(const QString &formatSpec, const QByteArray &array,
                                                   qreal value, int precision, const QString &preStr,
                                                   const QString &postStr) const
             {
                 QString retVal;
                 if (!formatSpec.isEmpty()) {
                     if (formatSpec.at(0) == QLatin1Char('d')
                         || formatSpec.at(0) == QLatin1Char('i')
                         || formatSpec.at(0) == QLatin1Char('c')) {
                         if (presenter()->localizeNumbers())
                             retVal = preStr + presenter()->locale().toString(qint64(value)) + postStr;
                         else
                             retVal = QString().sprintf(array, qint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('u')
                              || formatSpec.at(0) == QLatin1Char('o')
                              || formatSpec.at(0) == QLatin1Char('x')
                              || formatSpec.at(0) == QLatin1Char('X')) {
                         // These formats are not supported by localized numbers
                         retVal = QString().sprintf(array, quint64(value));
                     } else if (formatSpec.at(0) == QLatin1Char('f')
                                || formatSpec.at(0) == QLatin1Char('F')
                                || formatSpec.at(0) == QLatin1Char('e')
                                || formatSpec.at(0) == QLatin1Char('E')
                                || formatSpec.at(0) == QLatin1Char('g')
                                || formatSpec.at(0) == QLatin1Char('G')) {
                         if (presenter()->localizeNumbers()) {
                             retVal = preStr
                                     + presenter()->locale().toString(value, formatSpec.at(0).toLatin1(),
                                                                      precision)
                                     + postStr;
                         } else {
                             retVal = QString().sprintf(array, value);
                         }
                     }
                 }
                 return retVal;
             }
             QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks,
                                                             const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 if (format.isNull()) {
                     int n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0) + 1;
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
                     int precision = 6; // Six is the default precision in Qt API
                     if (presenter()->localizeNumbers()) {
                         if (!labelFormatMatcherLocalized)
                             labelFormatMatcherLocalized
                                     = new QRegExp(QString::fromLatin1(labelFormatMatchLocalizedString));
                         if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
                             preStr = labelFormatMatcherLocalized->cap(1);
                             if (!labelFormatMatcherLocalized->cap(2).isEmpty())
                                 precision = labelFormatMatcherLocalized->cap(2).toInt();
                             formatSpec = labelFormatMatcherLocalized->cap(3);
                             postStr = labelFormatMatcherLocalized->cap(4);
                         }
                     } else {
                         if (!labelFormatMatcher)
                             labelFormatMatcher = new QRegExp(QString::fromLatin1(labelFormatMatchString));
                         if (labelFormatMatcher->indexIn(format, 0) != -1)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int firstTick;
                 if (base > 1)
                     firstTick = qCeil(std::log10(min) / std::log10(base));
                 else
                     firstTick = qCeil(std::log10(max) / std::log10(base));
                 if (format.isNull()) {
                     int n = 0;
                     if (ticks > 1)
                         n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0);
                     n++;
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << presenter()->numberToString(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString formatSpec;
                     QString preStr;
                     QString postStr;
                     int precision = 6; // Six is the default precision in Qt API
                     if (presenter()->localizeNumbers()) {
                         if (!labelFormatMatcherLocalized)
                             labelFormatMatcherLocalized =
                                     new QRegExp(QString::fromLatin1(labelFormatMatchLocalizedString));
                         if (labelFormatMatcherLocalized->indexIn(format, 0) != -1) {
                             preStr = labelFormatMatcherLocalized->cap(1);
                             if (!labelFormatMatcherLocalized->cap(2).isEmpty())
                                 precision = labelFormatMatcherLocalized->cap(2).toInt();
                             formatSpec = labelFormatMatcherLocalized->cap(3);
                             postStr = labelFormatMatcherLocalized->cap(4);
                         }
                     } else {
                         if (!labelFormatMatcher)
                             labelFormatMatcher = new QRegExp(QString::fromLatin1(labelFormatMatchString));
                         if (labelFormatMatcher->indexIn(format, 0) != -1)
                             formatSpec = labelFormatMatcher->cap(1);
                     }
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << formatLabel(formatSpec, array, value, precision, preStr, postStr);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,
                                                                const QString &format) const
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << presenter()->locale().toString(QDateTime::fromMSecsSinceEpoch(value), format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/chartaxiselement_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CHARTAXISELEMENT_H
             #define CHARTAXISELEMENT_H
             #include <QtCharts/QChartGlobal>
             #include <private/chartelement_p.h>
             #include <private/axisanimation_p.h>
             #include <QtWidgets/QGraphicsItem>
             #include <QtWidgets/QGraphicsLayoutItem>
             #include <QtGui/QFont>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractAxis;
             class ChartAxisElement : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 using QGraphicsLayoutItem::setGeometry;
             public:
                 ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~ChartAxisElement();
                 virtual QRectF gridGeometry() const = 0;
                 virtual void setGeometry(const QRectF &axis, const QRectF &grid) = 0;
                 virtual bool isEmpty() = 0;
                 void setAnimation(AxisAnimation *animation) { m_animation = animation; }
                 AxisAnimation *animation() const { return m_animation; }
                 QAbstractAxis *axis() const { return m_axis; }
                 void setLayout(QVector<qreal> &layout) { m_layout = layout; }
                 QVector<qreal> &layout() { return m_layout; } // Modifiable reference
                 inline qreal labelPadding() const { return qreal(4.0); }
                 inline qreal titlePadding() const { return qreal(2.0); }
                 void setLabels(const QStringList &labels) { m_labelsList = labels; }
                 QStringList labels() const { return m_labelsList; }
                 qreal min() const;
                 qreal max() const;
                 QRectF axisGeometry() const { return m_axisRect; }
                 void setAxisGeometry(const QRectF &axisGeometry) { m_axisRect = axisGeometry; }
                 void axisSelected();
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format) const;
                 QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks,
                                                  const QString &format) const;
                 QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format) const;
                 // from QGraphicsLayoutItem
                 QRectF boundingRect() const
                 {
                     return QRectF();
                 }
                 // from QGraphicsLayoutItem
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             protected:
                 virtual QVector<qreal> calculateLayout() const = 0;
                 virtual void updateLayout(QVector<qreal> &layout) = 0;
                 QList<QGraphicsItem *> gridItems() { return m_grid->childItems(); }
                 QList<QGraphicsItem *> minorGridItems() { return m_minorGrid->childItems(); }
                 QList<QGraphicsItem *> labelItems() { return m_labels->childItems(); }
                 QList<QGraphicsItem *> shadeItems() { return m_shades->childItems(); }
                 QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems(); }
                 QList<QGraphicsItem *> minorArrowItems() { return m_minorArrow->childItems(); }
                 QGraphicsTextItem *titleItem() const { return m_title.data(); }
                 QGraphicsItemGroup *gridGroup() { return m_grid.data(); }
                 QGraphicsItemGroup *minorGridGroup() { return m_minorGrid.data(); }
                 QGraphicsItemGroup *labelGroup() { return m_labels.data(); }
                 QGraphicsItemGroup *shadeGroup() { return m_shades.data(); }
                 QGraphicsItemGroup *arrowGroup() { return m_arrow.data(); }
                 QGraphicsItemGroup *minorArrowGroup() { return m_minorArrow.data(); }
             public Q_SLOTS:
                 void handleVisibleChanged(bool visible);
                 void handleArrowVisibleChanged(bool visible);
                 void handleGridVisibleChanged(bool visible);
                 void handleLabelsVisibleChanged(bool visible);
                 void handleShadesVisibleChanged(bool visible);
                 void handleLabelsAngleChanged(int angle);
                 virtual void handleShadesBrushChanged(const QBrush &brush) = 0;
                 virtual void handleShadesPenChanged(const QPen &pen) = 0;
                 virtual void handleArrowPenChanged(const QPen &pen) = 0;
                 virtual void handleGridPenChanged(const QPen &pen) = 0;
                 virtual void handleMinorArrowPenChanged(const QPen &pen) = 0;
                 virtual void handleMinorGridPenChanged(const QPen &pen) = 0;
+                virtual void handleMinorGridLineColorChanged(const QColor &color) = 0;
+                virtual void handleGridLineColorChanged(const QColor &color) = 0;
                 void handleLabelsBrushChanged(const QBrush &brush);
                 void handleLabelsFontChanged(const QFont &font);
                 void handleTitleBrushChanged(const QBrush &brush);
                 void handleTitleFontChanged(const QFont &font);
                 void handleTitleTextChanged(const QString &title);
                 void handleTitleVisibleChanged(bool visible);
                 void handleRangeChanged(qreal min, qreal max);
                 void handleReverseChanged(bool reverse);
                 void handleMinorArrowVisibleChanged(bool visible);
                 void handleMinorGridVisibleChanged(bool visible);
                 void handleLabelsPositionChanged();
             Q_SIGNALS:
                 void clicked();
             private:
                 void connectSlots();
                 QString formatLabel(const QString &formatSpec, const QByteArray &array,
                                     qreal value, int precision, const QString &preStr,
                                     const QString &postStr) const;
                 QAbstractAxis *m_axis;
                 AxisAnimation *m_animation;
                 QVector<qreal> m_layout;
                 QStringList m_labelsList;
                 QRectF m_axisRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_minorGrid;
                 QScopedPointer<QGraphicsItemGroup> m_minorArrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsTextItem> m_title;
                 bool m_intervalAxis;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTAXISELEMENT_H */

src/charts/axis/polarchartaxisangular.cpp +20 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/polarchartaxisangular_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QDebug>
             #include <QtCore/QtMath>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             PolarChartAxisAngular::PolarChartAxisAngular(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisAngular::~PolarChartAxisAngular()
             {
             }
             void PolarChartAxisAngular::updateGeometry()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 const QVector<qreal> &layout = this->layout();
                 if (layout.isEmpty())
                     return;
                 createAxisLabels(layout);
                 QStringList labelList = labels();
                 QPointF center = axisGeometry().center();
                 QList<QGraphicsItem *> arrowItemList = arrowItems();
                 QList<QGraphicsItem *> gridItemList = gridItems();
                 QList<QGraphicsItem *> labelItemList = labelItems();
                 QList<QGraphicsItem *> shadeItemList = shadeItems();
                 QList<QGraphicsItem *> minorGridItemList = minorGridItems();
                 QList<QGraphicsItem *> minorArrowItemList = minorArrowItems();
                 QGraphicsTextItem *title = titleItem();
                 QGraphicsEllipseItem *axisLine = static_cast<QGraphicsEllipseItem *>(arrowItemList.at(0));
                 axisLine->setRect(axisGeometry());
                 qreal radius = axisGeometry().height() / 2.0;
                 QRectF previousLabelRect;
                 QRectF firstLabelRect;
                 qreal labelHeight = 0;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > 360.0);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal angularCoordinate = layout.at(i);
                     QGraphicsLineItem *gridLineItem = static_cast<QGraphicsLineItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labelItemList.at(i));
                     QGraphicsPathItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
                     // Ignore ticks outside valid range
                     bool currentTickVisible = nextTickVisible;
                     if ((i == layout.size() - 1)
                         || layout.at(i + 1) < 0.0
                         || layout.at(i + 1) > 360.0) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = angularCoordinate;
                     bool labelVisible = currentTickVisible;
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = 360.0;
                         else
                             farEdge = qMin(qreal(360.0), layout.at(i + 1));
                         // Adjust the labelCoordinate to show it if next tick is visible
                         if (nextTickVisible)
                             labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                         bool centeredLabel = true;
                         if (axis()->type() == QAbstractAxis::AxisTypeCategory) {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionOnValue)
                                 centeredLabel = false;
                         }
                         if (centeredLabel) {
                             labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                             // Don't display label once the category gets too small near the axis
                             if (labelCoordinate < 5.0 || labelCoordinate > 355.0)
                                 labelVisible = false;
                             else
                                 labelVisible = true;
                         } else {
                             labelVisible = nextTickVisible;
                             labelCoordinate = farEdge;
                         }
                     }
                     // Need this also in label calculations, so determine it first
                     QLineF tickLine(QLineF::fromPolar(radius - tickWidth(), 90.0 - angularCoordinate).p2(),
                                     QLineF::fromPolar(radius + tickWidth(), 90.0 - angularCoordinate).p2());
                     tickLine.translate(center);
                     // Angular axis label
                     if (axis()->labelsVisible() && labelVisible) {
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                labelList.at(i),
                                                                                axis()->labelsAngle());
                         labelItem->setTextWidth(boundingRect.width());
                         labelItem->setHtml(labelList.at(i));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(rect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint;
                         if (intervalAxis()) {
                             QLineF labelLine = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate);
                             labelLine.translate(center);
                             labelPoint = labelLine.p2();
                         } else {
                             labelPoint = tickLine.p2();
                         }
                         QRectF labelRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Store height for title calculations
                         qreal labelClearance = axisGeometry().top() - labelRect.top();
                         labelHeight = qMax(labelHeight, labelClearance);
                         // Label overlap detection
                         if (i && (previousLabelRect.intersects(labelRect) || firstLabelRect.intersects(labelRect))) {
                             labelVisible = false;
                         } else {
                             // Store labelRect for future comparison. Some area is deducted to make things look
                             // little nicer, as usually intersection happens at label corner with angular labels.
                             labelRect.adjust(-2.0, -4.0, -2.0, -4.0);
                             if (firstLabelRect.isEmpty())
                                 firstLabelRect = labelRect;
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridLineItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Angular grid line
                     QLineF gridLine = QLineF::fromPolar(radius, 90.0 - angularCoordinate);
                     gridLine.translate(center);
                     gridLineItem->setLine(gridLine);
                     gridLineItem->setVisible(true);
                     // Tick
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         path.moveTo(center);
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the first partial arc
                             // or it won't get filled.
                             path.arcTo(axisGeometry(), 90.0 - layout.at(0), layout.at(0));
                             path.closeSubpath();
                         } else {
                             qreal nextCoordinate;
                             if (!nextTickVisible) // Last visible tick
                                 nextCoordinate = 360.0;
                             else
                                 nextCoordinate = layout.at(i + 1);
                             qreal arcSpan = angularCoordinate - nextCoordinate;
                             path.arcTo(axisGeometry(), 90.0 - angularCoordinate, arcSpan);
                             path.closeSubpath();
                             // Add additional arc for first shade item if there is a partial arc to be filled
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QPainterPath specialPath;
                                     specialPath.moveTo(center);
                                     specialPath.arcTo(axisGeometry(), 90.0 - layout.at(i - 1), layout.at(i - 1));
                                     specialPath.closeSubpath();
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                     // Minor ticks
                     QValueAxis *valueAxis = qobject_cast<QValueAxis *>(axis());
                     if ((i + 1) != layout.size() && valueAxis) {
                         int minorTickCount = valueAxis->minorTickCount();
                         if (minorTickCount != 0) {
                             qreal minorAngularCoordinate = (layout[i + 1] - layout[i])
                                     / qreal(minorTickCount + 1);
                             for (int j = 0; j < minorTickCount; j++) {
                                 QGraphicsLineItem *minorGridItem =
                                         static_cast<QGraphicsLineItem *>(minorGridItemList.at(i * minorTickCount + j));
                                 QGraphicsLineItem *minorTickItem =
                                         static_cast<QGraphicsLineItem *>(minorArrowItemList.at(i * minorTickCount + j));
                                 qreal minorAngle = 90.0 - angularCoordinate
                                         - minorAngularCoordinate * qreal(j + 1);
                                 QLineF minorGridLine = QLineF::fromPolar(radius, minorAngle);
                                 minorGridLine.translate(center);
                                 minorGridItem->setLine(minorGridLine);
                                 minorGridItem->setVisible(true);
                                 QLineF minorTickLine(QLineF::fromPolar(radius - tickWidth() + 1,
                                                                        minorAngle).p2(),
                                                      QLineF::fromPolar(radius + tickWidth() - 1,
                                                                        minorAngle).p2());
                                 minorTickLine.translate(center);
                                 minorTickItem->setLine(minorTickLine);
                                 minorTickItem->setVisible(true);
                             }
                         }
                     }
                 }
                 // Title, centered above the chart
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
                     QRectF truncatedRect;
                     qreal availableTitleHeight = axisGeometry().height() - labelPadding() - titlePadding() * 2.0;
                     qreal minimumLabelHeight = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                 QStringLiteral("...")).height();
                     availableTitleHeight -= minimumLabelHeight;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  axisGeometry().width(), availableTitleHeight,
                                                                  truncatedRect));
                     title->setTextWidth(truncatedRect.width());
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = center - titleBoundingRect.center();
                     title->setPos(titleCenter.x(), axisGeometry().top() - titlePadding() * 2.0 - titleBoundingRect.height() - labelHeight);
                 }
             }
             Qt::Orientation PolarChartAxisAngular::orientation() const
             {
                 return Qt::Horizontal;
             }
             void PolarChartAxisAngular::createItems(int count)
             {
                 if (arrowItems().count() == 0) {
                     // angular axis line
                     QGraphicsEllipseItem *arrow = new QGraphicsEllipseItem(presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 QGraphicsTextItem *title = titleItem();
                 title->setFont(axis()->titleFont());
                 title->setDefaultTextColor(axis()->titleBrush().color());
                 title->setHtml(axis()->titleText());
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsLineItem *grid = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
                         shade->setPen(axis()->shadesPen());
                         shade->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shade);
                     }
                 }
             }
             void PolarChartAxisAngular::handleArrowPenChanged(const QPen &pen)
             {
                 bool first = true;
                 foreach (QGraphicsItem *item, arrowItems()) {
                     if (first) {
                         first = false;
                         // First arrow item is the outer circle of axis
                         static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
                     } else {
                         static_cast<QGraphicsLineItem *>(item)->setPen(pen);
                     }
                 }
             }
             void PolarChartAxisAngular::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void PolarChartAxisAngular::handleMinorArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorArrowItems()) {
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
                 }
             }
             void PolarChartAxisAngular::handleMinorGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorGridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
+            void PolarChartAxisAngular::handleGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, gridItems()) {
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
+                    QPen pen = lineItem->pen();
+                    pen.setColor(color);
+                    lineItem->setPen(pen);
+                }
+            }
+            void PolarChartAxisAngular::handleMinorGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, minorGridItems()) {
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
+                    QPen pen = lineItem->pen();
+                    pen.setColor(color);
+                    lineItem->setPen(pen);
+                }
+            }
             QSizeF PolarChartAxisAngular::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1, -1);
             }
             qreal PolarChartAxisAngular::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 if (axis()->labelsVisible()) {
                     QVector<qreal> layout = calculateLayout();
                     if (layout.isEmpty())
                         return radius;
                     createAxisLabels(layout);
                     QStringList labelList = labels();
                     QFont font = axis()->labelsFont();
                     QRectF maxRect;
                     maxRect.setSize(maxSize);
                     maxRect.moveCenter(QPointF(0.0, 0.0));
                     // This is a horrible way to find out the maximum radius for angular axis and its labels.
                     // It just increments the radius down until everyhing fits the constraint size.
                     // Proper way would be to actually calculate it but this seems to work reasonably fast as it is.
                     bool nextTickVisible = false;
                     for (int i = 0; i < layout.size(); ) {
                         if ((i == layout.size() - 1)
                             || layout.at(i + 1) < 0.0
                             || layout.at(i + 1) > 360.0) {
                             nextTickVisible = false;
                         } else {
                             nextTickVisible = true;
                         }
                         qreal labelCoordinate = layout.at(i);
                         qreal labelVisible;
                         if (intervalAxis()) {
                             qreal farEdge;
                             if (i == (layout.size() - 1))
                                 farEdge = 360.0;
                             else
                                 farEdge = qMin(qreal(360.0), layout.at(i + 1));
                             // Adjust the labelCoordinate to show it if next tick is visible
                             if (nextTickVisible)
                                 labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                             labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         }
                         if (labelCoordinate < 0.0 || labelCoordinate > 360.0)
                             labelVisible = false;
                         else
                             labelVisible = true;
                         if (!labelVisible) {
                             i++;
                             continue;
                         }
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         QPointF labelPoint = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate).p2();
                         boundingRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         QRectF intersectRect = maxRect.intersected(boundingRect);
                         if (boundingRect.isEmpty() || intersectRect == boundingRect) {
                             i++;
                         } else {
                             qreal reduction(0.0);
                             // If there is no intersection, reduce by smallest dimension of label rect to be on the safe side
                             if (intersectRect.isEmpty()) {
                                 reduction = qMin(boundingRect.height(), boundingRect.width());
                             } else {
                                 // Approximate needed radius reduction is the amount label rect exceeds max rect in either dimension.
                                 // Could be further optimized by figuring out the proper math how to calculate exact needed reduction.
                                 reduction = qMax(boundingRect.height() - intersectRect.height(),
                                                  boundingRect.width() - intersectRect.width());
                             }
                             // Typically the approximated reduction is little low, so add one
                             radius -= (reduction + 1.0);
                             if (radius < 1.0) // safeguard
                                 return 1.0;
                         }
                     }
                 }
                 if (!axis()->titleText().isEmpty() && axis()->isTitleVisible()) {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     radius -= titlePadding() + (titleRect.height() / 2.0);
                     if (radius < 1.0) // safeguard
                         return 1.0;
                 }
                 return radius;
             }
             QRectF PolarChartAxisAngular::moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const
             {
                 if (angularCoordinate == 0.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 else if (angularCoordinate < 90.0)
                     labelRect.moveBottomLeft(labelPoint);
                 else if (angularCoordinate == 90.0)
                     labelRect.moveCenter(labelPoint + QPointF(labelRect.width() / 2.0 + 2.0, 0)); // +2 so that it does not hit the radial axis
                 else if (angularCoordinate < 180.0)
                     labelRect.moveTopLeft(labelPoint);
                 else if (angularCoordinate == 180.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, labelRect.height() / 2.0));
                 else if (angularCoordinate < 270.0)
                     labelRect.moveTopRight(labelPoint);
                 else if (angularCoordinate == 270.0)
                     labelRect.moveCenter(labelPoint + QPointF(-labelRect.width() / 2.0 - 2.0, 0)); // -2 so that it does not hit the radial axis
                 else if (angularCoordinate < 360.0)
                     labelRect.moveBottomRight(labelPoint);
                 else
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 return labelRect;
             }
             void PolarChartAxisAngular::updateMinorTickItems()
             {
                 QValueAxis *valueAxis = qobject_cast<QValueAxis *>(this->axis());
                 if (valueAxis) {
                     int currentCount = minorArrowItems().size();
                     int expectedCount = valueAxis->minorTickCount() * (valueAxis->tickCount() - 1);
                     int diff = expectedCount - currentCount;
                     if (diff > 0) {
                         for (int i = 0; i < diff; i++) {
                             QGraphicsLineItem *minorArrow = new QGraphicsLineItem(presenter()->rootItem());
                             QGraphicsLineItem *minorGrid = new QGraphicsLineItem(presenter()->rootItem());
                             minorArrow->setPen(valueAxis->linePen());
                             minorGrid->setPen(valueAxis->minorGridLinePen());
                             minorArrowGroup()->addToGroup(minorArrow);
                             minorGridGroup()->addToGroup(minorGrid);
                         }
                     } else {
                         QList<QGraphicsItem *> minorGridLines = minorGridItems();
                         QList<QGraphicsItem *> minorArrows = minorArrowItems();
                         for (int i = 0; i > diff; i--) {
                             if (!minorGridLines.isEmpty())
                                 delete(minorGridLines.takeLast());
                             if (!minorArrows.isEmpty())
                                 delete(minorArrows.takeLast());
                         }
                     }
                 }
             }
             #include "moc_polarchartaxisangular_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/polarchartaxisangular_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 POLARCHARTAXISANGULAR_P_H
             #define POLARCHARTAXISANGULAR_P_H
             #include <private/polarchartaxis_p.h>
             #include <QtCharts/QValueAxis>
             QT_CHARTS_BEGIN_NAMESPACE
             class PolarChartAxisAngular : public PolarChartAxis
             {
                 Q_OBJECT
             public:
                 PolarChartAxisAngular(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~PolarChartAxisAngular();
                 Qt::Orientation orientation() const;
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 virtual void updateGeometry();
                 virtual void createItems(int count);
                 virtual void updateMinorTickItems();
                 qreal preferredAxisRadius(const QSizeF &maxSize);
             public Q_SLOTS:
                 virtual void handleArrowPenChanged(const QPen &pen);
                 virtual void handleGridPenChanged(const QPen &pen);
                 virtual void handleMinorArrowPenChanged(const QPen &pen);
                 virtual void handleMinorGridPenChanged(const QPen &pen);
+                virtual void handleGridLineColorChanged(const QColor &color);
+                virtual void handleMinorGridLineColorChanged(const QColor &color);
             private:
                 QRectF moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // POLARCHARTAXISANGULAR_P_H

src/charts/axis/polarchartaxisradial.cpp +20 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/polarchartaxisradial_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <private/qabstractaxis_p.h>
             #include <private/linearrowitem_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             PolarChartAxisRadial::PolarChartAxisRadial(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisRadial::~PolarChartAxisRadial()
             {
             }
             void PolarChartAxisRadial::updateGeometry()
             {
                 const QVector<qreal> &layout = this->layout();
                 if (layout.isEmpty())
                     return;
                 createAxisLabels(layout);
                 QStringList labelList = labels();
                 QPointF center = axisGeometry().center();
                 QList<QGraphicsItem *> arrowItemList = arrowItems();
                 QList<QGraphicsItem *> gridItemList = gridItems();
                 QList<QGraphicsItem *> labelItemList = labelItems();
                 QList<QGraphicsItem *> shadeItemList = shadeItems();
                 QList<QGraphicsItem *> minorGridItemList = minorGridItems();
                 QList<QGraphicsItem *> minorArrowItemList = minorArrowItems();
                 QGraphicsTextItem* title = titleItem();
                 qreal radius = axisGeometry().height() / 2.0;
                 QLineF line(center, center + QPointF(0, -radius));
                 QGraphicsLineItem *axisLine = static_cast<QGraphicsLineItem *>(arrowItemList.at(0));
                 axisLine->setLine(line);
                 QRectF previousLabelRect;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > radius);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal radialCoordinate = layout.at(i);
                     QGraphicsEllipseItem *gridItem = static_cast<QGraphicsEllipseItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labelItemList.at(i));
                     QGraphicsPathItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
                     // Ignore ticks outside valid range
                     bool currentTickVisible = nextTickVisible;
                     if ((i == layout.size() - 1)
                         || layout.at(i + 1) < 0.0
                         || layout.at(i + 1) > radius) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = radialCoordinate;
                     bool labelVisible = currentTickVisible;
                     qreal labelPad = labelPadding() / 2.0;
                     bool centeredLabel = true; // Only used with interval axes
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = radius;
                         else
                             farEdge = qMin(radius, layout.at(i + 1));
                         // Adjust the labelCoordinate to show it if next tick is visible
                         if (nextTickVisible)
                             labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                         if (axis()->type() == QAbstractAxis::AxisTypeCategory) {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionOnValue)
                                 centeredLabel = false;
                         }
                         if (centeredLabel) {
                             labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                             if (labelCoordinate > 0.0 && labelCoordinate < radius)
                                 labelVisible =  true;
                             else
                                 labelVisible = false;
                         } else {
                             labelVisible = nextTickVisible;
                             labelCoordinate = farEdge;
                         }
                     }
                     // Radial axis label
                     if (axis()->labelsVisible() && labelVisible) {
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                labelList.at(i),
                                                                                axis()->labelsAngle());
                         labelItem->setTextWidth(boundingRect.width());
                         labelItem->setHtml(labelList.at(i));
                         QRectF labelRect = labelItem->boundingRect();
                         QPointF labelCenter = labelRect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(labelRect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint = center;
                         if (intervalAxis() && centeredLabel)
                             labelPoint += QPointF(labelPad, -labelCoordinate - (boundingRect.height() / 2.0));
                         else
                             labelPoint += QPointF(labelPad, labelPad - labelCoordinate);
                         labelRect.moveTopLeft(labelPoint);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Label overlap detection
                         labelRect.setSize(boundingRect.size());
                         if ((i && previousLabelRect.intersects(labelRect))
                              || !axisGeometry().contains(labelRect)) {
                             labelVisible = false;
                         } else {
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Radial grid line
                     QRectF gridRect;
                     gridRect.setWidth(radialCoordinate * 2.0);
                     gridRect.setHeight(radialCoordinate * 2.0);
                     gridRect.moveCenter(center);
                     gridItem->setRect(gridRect);
                     gridItem->setVisible(true);
                     // Tick
                     QLineF tickLine(-tickWidth(), 0.0, tickWidth(), 0.0);
                     tickLine.translate(center.rx(), gridRect.top());
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the inner circle
                             // or it won't get filled.
                             QRectF innerCircle(0.0, 0.0, layout.at(0) * 2.0, layout.at(0) * 2.0);
                             innerCircle.moveCenter(center);
                             path.addEllipse(innerCircle);
                         } else {
                             QRectF otherGridRect;
                             if (!nextTickVisible) { // Last visible tick
                                 otherGridRect = axisGeometry();
                             } else {
                                 qreal otherGridRectDimension = layout.at(i + 1) * 2.0;
                                 otherGridRect.setWidth(otherGridRectDimension);
                                 otherGridRect.setHeight(otherGridRectDimension);
                                 otherGridRect.moveCenter(center);
                             }
                             path.addEllipse(gridRect);
                             path.addEllipse(otherGridRect);
                             // Add additional shading in first visible shade item if there is a partial tick
                             // to be filled at the center (log & category axes)
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QRectF innerCircle(0.0, 0.0, layout.at(i - 1) * 2.0, layout.at(i - 1) * 2.0);
                                     innerCircle.moveCenter(center);
                                     QPainterPath specialPath;
                                     specialPath.addEllipse(innerCircle);
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                     // Minor ticks
                     QValueAxis *valueAxis = qobject_cast<QValueAxis *>(axis());
                     if ((i + 1) != layout.size() && valueAxis) {
                         int minorTickCount = valueAxis->minorTickCount();
                         if (minorTickCount != 0) {
                             qreal minorRadialCoordinate = (layout[i + 1] - layout[i])
                                     / qreal(minorTickCount + 1) * 2.0;
                             for (int j = 0; j < minorTickCount; j++) {
                                 QGraphicsEllipseItem *minorGridItem =
                                         static_cast<QGraphicsEllipseItem *>(minorGridItemList.at(i * minorTickCount + j));
                                 QGraphicsLineItem *minorTickItem =
                                         static_cast<QGraphicsLineItem *>(minorArrowItemList.at(i * minorTickCount + j));
                                 QRectF minorGridRect;
                                 minorGridRect.setWidth(minorRadialCoordinate * qreal(i + 1)
                                                        + minorRadialCoordinate * qreal(i * minorTickCount + j));
                                 minorGridRect.setHeight(minorRadialCoordinate * qreal(i + 1)
                                                         + minorRadialCoordinate
                                                         * qreal(i * minorTickCount + j));
                                 minorGridRect.moveCenter(center);
                                 minorGridItem->setRect(minorGridRect);
                                 minorGridItem->setVisible(true);
                                 QLineF minorTickLine(-tickWidth() + 1, 0.0, tickWidth() - 1, 0.0);
                                 tickLine.translate(center.rx(), minorGridRect.top());
                                 minorTickItem->setLine(minorTickLine);
                                 minorTickItem->setVisible(true);
                             }
                         }
                     }
                 }
                 // Title, along the 0 axis
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
                     QRectF truncatedRect;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  radius, radius, truncatedRect));
                     title->setTextWidth(truncatedRect.width());
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = titleBoundingRect.center();
                     QPointF arrowCenter = axisLine->boundingRect().center();
                     QPointF titleCenterDiff = arrowCenter - titleCenter;
                     title->setPos(titleCenterDiff.x() - titlePadding() - (titleBoundingRect.height() / 2.0), titleCenterDiff.y());
                     title->setTransformOriginPoint(titleCenter);
                     title->setRotation(270.0);
                 }
                 QGraphicsLayoutItem::updateGeometry();
             }
             Qt::Orientation PolarChartAxisRadial::orientation() const
             {
                 return Qt::Vertical;
             }
             void PolarChartAxisRadial::createItems(int count)
             {
                  if (arrowItems().count() == 0) {
                     // radial axis center line
                     QGraphicsLineItem *arrow = new LineArrowItem(this, presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 QGraphicsTextItem *title = titleItem();
                 title->setFont(axis()->titleFont());
                 title->setDefaultTextColor(axis()->titleBrush().color());
                 title->setHtml(axis()->titleText());
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsEllipseItem *grid = new QGraphicsEllipseItem(presenter()->rootItem());
                     QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
                         shade->setPen(axis()->shadesPen());
                         shade->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shade);
                     }
                 }
             }
             void PolarChartAxisRadial::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void PolarChartAxisRadial::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
             }
             void PolarChartAxisRadial::handleMinorArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorArrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void PolarChartAxisRadial::handleMinorGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorGridItems())
                     static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
             }
+            void PolarChartAxisRadial::handleGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, gridItems()) {
+                    QGraphicsEllipseItem *ellipseItem = static_cast<QGraphicsEllipseItem *>(item);
+                    QPen pen = ellipseItem->pen();
+                    pen.setColor(color);
+                    ellipseItem->setPen(pen);
+                }
+            }
+            void PolarChartAxisRadial::handleMinorGridLineColorChanged(const QColor &color)
+            {
+                foreach (QGraphicsItem *item, minorGridItems()) {
+                    QGraphicsEllipseItem *ellipseItem = static_cast<QGraphicsEllipseItem *>(item);
+                    QPen pen = ellipseItem->pen();
+                    pen.setColor(color);
+                    ellipseItem->setPen(pen);
+                }
+            }
             QSizeF PolarChartAxisRadial::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1.0, -1.0);
             }
             qreal PolarChartAxisRadial::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 return radius;
             }
             void PolarChartAxisRadial::updateMinorTickItems()
             {
                 QValueAxis *valueAxis = qobject_cast<QValueAxis *>(this->axis());
                 if (valueAxis) {
                     int currentCount = minorArrowItems().size();
                     int expectedCount = valueAxis->minorTickCount() * (valueAxis->tickCount() - 1);
                     int diff = expectedCount - currentCount;
                     if (diff > 0) {
                         for (int i = 0; i < diff; i++) {
                             QGraphicsLineItem *minorArrow = new QGraphicsLineItem(presenter()->rootItem());
                             QGraphicsEllipseItem *minorGrid = new QGraphicsEllipseItem(presenter()->rootItem());
                             minorArrow->setPen(valueAxis->linePen());
                             minorGrid->setPen(valueAxis->minorGridLinePen());
                             minorArrowGroup()->addToGroup(minorArrow);
                             minorGridGroup()->addToGroup(minorGrid);
                         }
                     } else {
                         QList<QGraphicsItem *> minorGridLines = minorGridItems();
                         QList<QGraphicsItem *> minorArrows = minorArrowItems();
                         for (int i = 0; i > diff; i--) {
                             if (!minorGridLines.isEmpty())
                                 delete(minorGridLines.takeLast());
                             if (!minorArrows.isEmpty())
                                 delete(minorArrows.takeLast());
                         }
                     }
                 }
             }
             #include "moc_polarchartaxisradial_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/polarchartaxisradial_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 POLARCHARTAXISRADIAL_P_H
             #define POLARCHARTAXISRADIAL_P_H
             #include <private/polarchartaxis_p.h>
             #include <QtCharts/QValueAxis>
             QT_CHARTS_BEGIN_NAMESPACE
             class PolarChartAxisRadial : public PolarChartAxis
             {
                 Q_OBJECT
             public:
                 PolarChartAxisRadial(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~PolarChartAxisRadial();
                 Qt::Orientation orientation() const;
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 virtual void updateGeometry();
                 virtual void createItems(int count);
                 virtual void updateMinorTickItems();
                 qreal preferredAxisRadius(const QSizeF &maxSize);
             public Q_SLOTS:
                 virtual void handleArrowPenChanged(const QPen &pen);
                 virtual void handleGridPenChanged(const QPen &pen);
                 virtual void handleMinorArrowPenChanged(const QPen &pen);
                 virtual void handleMinorGridPenChanged(const QPen &pen);
+                virtual void handleGridLineColorChanged(const QColor &color);
+                virtual void handleMinorGridLineColorChanged(const QColor &color);
             };
             QT_CHARTS_END_NAMESPACE
             #endif // POLARCHARTAXISRADIAL_P_H

src/charts/axis/qabstractaxis.cpp +50 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \inmodule Qt Charts
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 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.
             */
             /*!
                 \qmltype AbstractAxis
                 \instantiates QAbstractAxis
                 \inqmlmodule QtCharts
                 \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 axis 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::labelsBrush
               The brush of the labels. Only the color of the brush is relevant.
             */
             /*!
               \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::minorGridVisible
               The visibility of the minor grid lines. Applies only to QValueAxis.
             */
             /*!
               \qmlproperty bool AbstractAxis::minorGridVisible
               The visibility of the minor grid lines. Applies only to QValueAxis.
             */
             /*!
               \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::minorGridLinePen
               The pen of the minor grid line. Applies only to QValueAxis.
             */
             /*!
+              \property QAbstractAxis::gridLineColor
+              The color of the grid line.
+            */
+            /*!
+              \property QAbstractAxis::minorGridLineColor
+              The color of the minor grid line. Applies only to QValueAxis.
+            */
+            /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the Qt documentation for more details of Font.
             */
             /*!
               \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. Axis titles support html formatting.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text. Only the color of the brush is relevant.
             */
             /*!
               \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.
             */
             /*!
               \property QAbstractAxis::reverse
               The reverse property defines if reverse axis is used. By default the value is false.
               Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
               All axes of the same orientation attached to same series must be reversed if one is reversed or
               the behavior is undefined.
             */
             /*!
               \qmlproperty alignment AbstractAxis::reverse
               The reverse property defines if reverse axis is used. By default the value is false.
               Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
               All axes of the same orientation attached to same series must be reversed if one is reversed or
               the behavior is undefined.
             */
             /*!
               \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::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::minorGridVisibleChanged(bool visible)
               Visibility of the minor grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onMinorGridVisibleChanged(bool visible)
               Visibility of the minor 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::minorGridLinePenChanged(const QPen& pen)
               The pen of the minor grid line has changed to \a pen.
             */
             /*!
+              \fn void QAbstractAxis::gridLineColorChanged(const QColor &color)
+              The color of the pen of the grid line has changed to \a color.
+            */
+            /*!
+              \fn void QAbstractAxis::minorGridLineColorChanged(const QColor &color)
+              The color of the pen of the minor grid line has changed to \a color.
+            */
+            /*!
               \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::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;
             }
             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;
             }
             void QAbstractAxis::setMinorGridLineVisible(bool visible)
             {
                 if (d_ptr->m_minorGridLineVisible != visible) {
                     d_ptr->m_minorGridLineVisible = visible;
                     emit minorGridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isMinorGridLineVisible() const
             {
                 return d_ptr->m_minorGridLineVisible;
             }
             /*!
               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::setMinorGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_minorGridLinePen != pen) {
                     d_ptr->m_minorGridLinePen = pen;
                     emit minorGridLinePenChanged(pen);
                 }
             }
             QPen QAbstractAxis::minorGridLinePen() const
             {
                 if (d_ptr->m_minorGridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_minorGridLinePen;
             }
+            void QAbstractAxis::setGridLineColor(const QColor &color)
+            {
+                QPen pen = d_ptr->m_gridLinePen;
+                if (color != pen.color()) {
+                    pen.setColor(color);
+                    d_ptr->m_gridLinePen = pen;
+                    emit gridLineColorChanged(color);
+                }
+            }
+            QColor QAbstractAxis::gridLineColor()
+            {
+                return d_ptr->m_gridLinePen.color();
+            }
+            void QAbstractAxis::setMinorGridLineColor(const QColor &color)
+            {
+                QPen pen = d_ptr->m_minorGridLinePen;
+                if (color != pen.color()) {
+                    pen.setColor(color);
+                    d_ptr->m_minorGridLinePen = pen;
+                    emit minorGridLineColorChanged(color);
+                }
+            }
+            QColor QAbstractAxis::minorGridLineColor()
+            {
+                return d_ptr->m_minorGridLinePen.color();
+            }
             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 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;
             }
             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 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)
             */
             Qt::Orientation QAbstractAxis::orientation() const
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             bool QAbstractAxis::isReverse() const
             {
                 return d_ptr->m_reverse;
             }
             void QAbstractAxis::setReverse(bool reverse)
             {
                 if (d_ptr->m_reverse != reverse && type() != QAbstractAxis::AxisTypeBarCategory) {
                     d_ptr->m_reverse = reverse;
                     emit reverseChanged(reverse);
                 }
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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_minorGridLineVisible(true),
                   m_minorGridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   m_shadesOpacity(1.0),
                   m_dirty(false),
                   m_reverse(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)
             {
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->gridLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_minorGridLinePen)
                     q_ptr->setMinorGridLinePen(theme->minorGridLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 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::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, int duration,
                                                             QEasingCurve &curve)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (axis->animation())
                     axis->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::GridAxisAnimations))
                     axis->setAnimation(new AxisAnimation(axis, duration, curve));
                 else
                     axis->setAnimation(0);
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/qabstractaxis.h +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <QtCharts/QChartGlobal>
             #include <QtGui/QPen>
             #include <QtGui/QFont>
             #include <QtCore/QVariant>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QT_CHARTS_EXPORT QAbstractAxis : public QObject
             {
                 Q_OBJECT
                 //visibility
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 //arrow
                 Q_PROPERTY(bool lineVisible READ isLineVisible WRITE setLineVisible NOTIFY lineVisibleChanged)
                 Q_PROPERTY(QPen linePen READ linePen WRITE setLinePen NOTIFY linePenChanged)
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QBrush labelsBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(QPen gridLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 Q_PROPERTY(bool minorGridVisible READ isMinorGridLineVisible WRITE setMinorGridLineVisible NOTIFY minorGridVisibleChanged)
                 Q_PROPERTY(QPen minorGridLinePen READ minorGridLinePen WRITE setMinorGridLinePen NOTIFY minorGridLinePenChanged)
+                Q_PROPERTY(QColor gridLineColor READ gridLineColor WRITE setGridLineColor NOTIFY gridLineColorChanged)
+                Q_PROPERTY(QColor minorGridLineColor READ minorGridLineColor WRITE setMinorGridLineColor NOTIFY minorGridLineColorChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
                 Q_PROPERTY(QPen shadesPen READ shadesPen WRITE setShadesPen NOTIFY shadesPenChanged)
                 Q_PROPERTY(QBrush shadesBrush READ shadesBrush WRITE setShadesBrush NOTIFY shadesBrushChanged)
                 //title
                 Q_PROPERTY(QString titleText READ titleText WRITE setTitleText NOTIFY titleTextChanged)
                 Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ isTitleVisible WRITE setTitleVisible NOTIFY titleVisibleChanged)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont NOTIFY titleFontChanged)
                 //orientation
                 Q_PROPERTY(Qt::Orientation orientation READ orientation)
                 //aligment
                 Q_PROPERTY(Qt::Alignment alignment READ alignment)
                 Q_PROPERTY(bool reverse READ isReverse WRITE setReverse NOTIFY reverseChanged)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
                     AxisTypeCategory = 0x4,
                     AxisTypeDateTime = 0x8,
                     AxisTypeLogValue = 0x10
                 };
                 Q_DECLARE_FLAGS(AxisTypes, AxisType)
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //visibility handling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
                 void show();
                 void hide();
                 //arrow handling
                 bool isLineVisible() const;
                 void setLineVisible(bool visible = true);
                 void setLinePen(const QPen &pen);
                 QPen linePen() const;
                 void setLinePenColor(QColor color);
                 QColor linePenColor() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 bool isMinorGridLineVisible() const;
                 void setMinorGridLineVisible(bool visible = true);
                 void setMinorGridLinePen(const QPen &pen);
                 QPen minorGridLinePen() const;
+                void setGridLineColor(const QColor &color);
+                QColor gridLineColor();
+                void setMinorGridLineColor(const QColor &color);
+                QColor minorGridLineColor();
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() const;
                 //title handling
                 bool isTitleVisible() const;
                 void setTitleVisible(bool visible = true);
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleText(const QString &title);
                 QString titleText() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
                 Qt::Orientation orientation() const;
                 Qt::Alignment alignment() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
                 //reverse handling
                 void setReverse(bool reverse = true);
                 bool isReverse() const;
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void linePenChanged(const QPen &pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void labelsBrushChanged(const QBrush &brush);
                 void labelsFontChanged(const QFont &pen);
                 void labelsAngleChanged(int angle);
                 void gridLinePenChanged(const QPen &pen);
                 void gridVisibleChanged(bool visible);
                 void minorGridVisibleChanged(bool visible);
                 void minorGridLinePenChanged(const QPen &pen);
+                void gridLineColorChanged(const QColor &color);
+                void minorGridLineColorChanged(const QColor &color);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void titleTextChanged(const QString &title);
                 void titleBrushChanged(const QBrush &brush);
                 void titleVisibleChanged(bool visible);
                 void titleFontChanged(const QFont &font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
                 void shadesPenChanged(const QPen &pen);
                 void shadesBrushChanged(const QBrush &brush);
                 void reverseChanged(bool reverse);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class AbstractDomain;
                 friend class ChartAxisElement;
                 friend class XYChart;
             private:
                 Q_DISABLE_COPY(QAbstractAxis)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

src/chartsqml2/plugins.qmltypes +10 0

             import QtQuick.tooling 1.2
             // This file describes the plugin-supplied types contained in the library.
             // It is used for QML tooling purposes only.
             //
             // This file was auto-generated by:
             // 'qmlplugindump -nonrelocatable QtCharts 2.0'
             Module {
                 dependencies: []
                 Component {
                     name: "QAbstractItemModel"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/AbstractItemModel 1.0",
                         "QtCharts/AbstractItemModel 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "LayoutChangeHint"
                         values: {
                             "NoLayoutChangeHint": 0,
                             "VerticalSortHint": 1,
                             "HorizontalSortHint": 2
                         }
                     }
                     Signal {
                         name: "dataChanged"
                         Parameter { name: "topLeft"; type: "QModelIndex" }
                         Parameter { name: "bottomRight"; type: "QModelIndex" }
                         Parameter { name: "roles"; type: "QVector<int>" }
                     }
                     Signal {
                         name: "dataChanged"
                         Parameter { name: "topLeft"; type: "QModelIndex" }
                         Parameter { name: "bottomRight"; type: "QModelIndex" }
                     }
                     Signal {
                         name: "headerDataChanged"
                         Parameter { name: "orientation"; type: "Qt::Orientation" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "layoutChanged"
                         Parameter { name: "parents"; type: "QList<QPersistentModelIndex>" }
                         Parameter { name: "hint"; type: "QAbstractItemModel::LayoutChangeHint" }
                     }
                     Signal {
                         name: "layoutChanged"
                         Parameter { name: "parents"; type: "QList<QPersistentModelIndex>" }
                     }
                     Signal { name: "layoutChanged" }
                     Signal {
                         name: "layoutAboutToBeChanged"
                         Parameter { name: "parents"; type: "QList<QPersistentModelIndex>" }
                         Parameter { name: "hint"; type: "QAbstractItemModel::LayoutChangeHint" }
                     }
                     Signal {
                         name: "layoutAboutToBeChanged"
                         Parameter { name: "parents"; type: "QList<QPersistentModelIndex>" }
                     }
                     Signal { name: "layoutAboutToBeChanged" }
                     Signal {
                         name: "rowsAboutToBeInserted"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "rowsInserted"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "rowsAboutToBeRemoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "rowsRemoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "columnsAboutToBeInserted"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "columnsInserted"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "columnsAboutToBeRemoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal {
                         name: "columnsRemoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "first"; type: "int" }
                         Parameter { name: "last"; type: "int" }
                     }
                     Signal { name: "modelAboutToBeReset" }
                     Signal { name: "modelReset" }
                     Signal {
                         name: "rowsAboutToBeMoved"
                         Parameter { name: "sourceParent"; type: "QModelIndex" }
                         Parameter { name: "sourceStart"; type: "int" }
                         Parameter { name: "sourceEnd"; type: "int" }
                         Parameter { name: "destinationParent"; type: "QModelIndex" }
                         Parameter { name: "destinationRow"; type: "int" }
                     }
                     Signal {
                         name: "rowsMoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "start"; type: "int" }
                         Parameter { name: "end"; type: "int" }
                         Parameter { name: "destination"; type: "QModelIndex" }
                         Parameter { name: "row"; type: "int" }
                     }
                     Signal {
                         name: "columnsAboutToBeMoved"
                         Parameter { name: "sourceParent"; type: "QModelIndex" }
                         Parameter { name: "sourceStart"; type: "int" }
                         Parameter { name: "sourceEnd"; type: "int" }
                         Parameter { name: "destinationParent"; type: "QModelIndex" }
                         Parameter { name: "destinationColumn"; type: "int" }
                     }
                     Signal {
                         name: "columnsMoved"
                         Parameter { name: "parent"; type: "QModelIndex" }
                         Parameter { name: "start"; type: "int" }
                         Parameter { name: "end"; type: "int" }
                         Parameter { name: "destination"; type: "QModelIndex" }
                         Parameter { name: "column"; type: "int" }
                     }
                     Method { name: "submit"; type: "bool" }
                     Method { name: "revert" }
                     Method {
                         name: "hasIndex"
                         type: "bool"
                         Parameter { name: "row"; type: "int" }
                         Parameter { name: "column"; type: "int" }
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method {
                         name: "hasIndex"
                         type: "bool"
                         Parameter { name: "row"; type: "int" }
                         Parameter { name: "column"; type: "int" }
                     }
                     Method {
                         name: "index"
                         type: "QModelIndex"
                         Parameter { name: "row"; type: "int" }
                         Parameter { name: "column"; type: "int" }
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method {
                         name: "index"
                         type: "QModelIndex"
                         Parameter { name: "row"; type: "int" }
                         Parameter { name: "column"; type: "int" }
                     }
                     Method {
                         name: "parent"
                         type: "QModelIndex"
                         Parameter { name: "child"; type: "QModelIndex" }
                     }
                     Method {
                         name: "sibling"
                         type: "QModelIndex"
                         Parameter { name: "row"; type: "int" }
                         Parameter { name: "column"; type: "int" }
                         Parameter { name: "idx"; type: "QModelIndex" }
                     }
                     Method {
                         name: "rowCount"
                         type: "int"
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method { name: "rowCount"; type: "int" }
                     Method {
                         name: "columnCount"
                         type: "int"
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method { name: "columnCount"; type: "int" }
                     Method {
                         name: "hasChildren"
                         type: "bool"
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method { name: "hasChildren"; type: "bool" }
                     Method {
                         name: "data"
                         type: "QVariant"
                         Parameter { name: "index"; type: "QModelIndex" }
                         Parameter { name: "role"; type: "int" }
                     }
                     Method {
                         name: "data"
                         type: "QVariant"
                         Parameter { name: "index"; type: "QModelIndex" }
                     }
                     Method {
                         name: "setData"
                         type: "bool"
                         Parameter { name: "index"; type: "QModelIndex" }
                         Parameter { name: "value"; type: "QVariant" }
                         Parameter { name: "role"; type: "int" }
                     }
                     Method {
                         name: "setData"
                         type: "bool"
                         Parameter { name: "index"; type: "QModelIndex" }
                         Parameter { name: "value"; type: "QVariant" }
                     }
                     Method {
                         name: "headerData"
                         type: "QVariant"
                         Parameter { name: "section"; type: "int" }
                         Parameter { name: "orientation"; type: "Qt::Orientation" }
                         Parameter { name: "role"; type: "int" }
                     }
                     Method {
                         name: "headerData"
                         type: "QVariant"
                         Parameter { name: "section"; type: "int" }
                         Parameter { name: "orientation"; type: "Qt::Orientation" }
                     }
                     Method {
                         name: "fetchMore"
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method {
                         name: "canFetchMore"
                         type: "bool"
                         Parameter { name: "parent"; type: "QModelIndex" }
                     }
                     Method {
                         name: "flags"
                         type: "Qt::ItemFlags"
                         Parameter { name: "index"; type: "QModelIndex" }
                     }
                     Method {
                         name: "match"
                         type: "QModelIndexList"
                         Parameter { name: "start"; type: "QModelIndex" }
                         Parameter { name: "role"; type: "int" }
                         Parameter { name: "value"; type: "QVariant" }
                         Parameter { name: "hits"; type: "int" }
                         Parameter { name: "flags"; type: "Qt::MatchFlags" }
                     }
                     Method {
                         name: "match"
                         type: "QModelIndexList"
                         Parameter { name: "start"; type: "QModelIndex" }
                         Parameter { name: "role"; type: "int" }
                         Parameter { name: "value"; type: "QVariant" }
                         Parameter { name: "hits"; type: "int" }
                     }
                     Method {
                         name: "match"
                         type: "QModelIndexList"
                         Parameter { name: "start"; type: "QModelIndex" }
                         Parameter { name: "role"; type: "int" }
                         Parameter { name: "value"; type: "QVariant" }
                     }
                 }
                 Component {
                     name: "QGraphicsObject"
                     defaultProperty: "children"
                     prototype: "QObject"
                     Property { name: "parent"; type: "QGraphicsObject"; isPointer: true }
                     Property { name: "opacity"; type: "double" }
                     Property { name: "enabled"; type: "bool" }
                     Property { name: "visible"; type: "bool" }
                     Property { name: "pos"; type: "QPointF" }
                     Property { name: "x"; type: "double" }
                     Property { name: "y"; type: "double" }
                     Property { name: "z"; type: "double" }
                     Property { name: "rotation"; type: "double" }
                     Property { name: "scale"; type: "double" }
                     Property { name: "transformOriginPoint"; type: "QPointF" }
                     Property { name: "effect"; type: "QGraphicsEffect"; isPointer: true }
                     Property {
                         name: "children"
                         type: "QDeclarativeListProperty<QGraphicsObject>"
                         isReadonly: true
                     }
                     Property { name: "width"; type: "double" }
                     Property { name: "height"; type: "double" }
                 }
                 Component {
                     name: "QGraphicsWidget"
                     defaultProperty: "children"
                     prototype: "QGraphicsObject"
                     Property { name: "palette"; type: "QPalette" }
                     Property { name: "font"; type: "QFont" }
                     Property { name: "layoutDirection"; type: "Qt::LayoutDirection" }
                     Property { name: "size"; type: "QSizeF" }
                     Property { name: "minimumSize"; type: "QSizeF" }
                     Property { name: "preferredSize"; type: "QSizeF" }
                     Property { name: "maximumSize"; type: "QSizeF" }
                     Property { name: "sizePolicy"; type: "QSizePolicy" }
                     Property { name: "focusPolicy"; type: "Qt::FocusPolicy" }
                     Property { name: "windowFlags"; type: "Qt::WindowFlags" }
                     Property { name: "windowTitle"; type: "string" }
                     Property { name: "geometry"; type: "QRectF" }
                     Property { name: "autoFillBackground"; type: "bool" }
                     Property { name: "layout"; type: "QGraphicsLayout"; isPointer: true }
                     Method { name: "close"; type: "bool" }
                 }
                 Component {
                     name: "QQuickItem"
                     defaultProperty: "data"
                     prototype: "QObject"
                     Enum {
                         name: "TransformOrigin"
                         values: {
                             "TopLeft": 0,
                             "Top": 1,
                             "TopRight": 2,
                             "Left": 3,
                             "Center": 4,
                             "Right": 5,
                             "BottomLeft": 6,
                             "Bottom": 7,
                             "BottomRight": 8
                         }
                     }
                     Property { name: "parent"; type: "QQuickItem"; isPointer: true }
                     Property { name: "data"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "resources"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "children"; type: "QQuickItem"; isList: true; isReadonly: true }
                     Property { name: "x"; type: "double" }
                     Property { name: "y"; type: "double" }
                     Property { name: "z"; type: "double" }
                     Property { name: "width"; type: "double" }
                     Property { name: "height"; type: "double" }
                     Property { name: "opacity"; type: "double" }
                     Property { name: "enabled"; type: "bool" }
                     Property { name: "visible"; type: "bool" }
                     Property { name: "visibleChildren"; type: "QQuickItem"; isList: true; isReadonly: true }
                     Property { name: "states"; type: "QQuickState"; isList: true; isReadonly: true }
                     Property { name: "transitions"; type: "QQuickTransition"; isList: true; isReadonly: true }
                     Property { name: "state"; type: "string" }
                     Property { name: "childrenRect"; type: "QRectF"; isReadonly: true }
                     Property { name: "anchors"; type: "QQuickAnchors"; isReadonly: true; isPointer: true }
                     Property { name: "left"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "right"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "horizontalCenter"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "top"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "bottom"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "verticalCenter"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "baseline"; type: "QQuickAnchorLine"; isReadonly: true }
                     Property { name: "baselineOffset"; type: "double" }
                     Property { name: "clip"; type: "bool" }
                     Property { name: "focus"; type: "bool" }
                     Property { name: "activeFocus"; type: "bool"; isReadonly: true }
                     Property { name: "activeFocusOnTab"; revision: 1; type: "bool" }
                     Property { name: "rotation"; type: "double" }
                     Property { name: "scale"; type: "double" }
                     Property { name: "transformOrigin"; type: "TransformOrigin" }
                     Property { name: "transformOriginPoint"; type: "QPointF"; isReadonly: true }
                     Property { name: "transform"; type: "QQuickTransform"; isList: true; isReadonly: true }
                     Property { name: "smooth"; type: "bool" }
                     Property { name: "antialiasing"; type: "bool" }
                     Property { name: "implicitWidth"; type: "double" }
                     Property { name: "implicitHeight"; type: "double" }
                     Property { name: "layer"; type: "QQuickItemLayer"; isReadonly: true; isPointer: true }
                     Signal {
                         name: "childrenRectChanged"
                         Parameter { type: "QRectF" }
                     }
                     Signal {
                         name: "baselineOffsetChanged"
                         Parameter { type: "double" }
                     }
                     Signal {
                         name: "stateChanged"
                         Parameter { type: "string" }
                     }
                     Signal {
                         name: "focusChanged"
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "activeFocusChanged"
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "activeFocusOnTabChanged"
                         revision: 1
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "parentChanged"
                         Parameter { type: "QQuickItem"; isPointer: true }
                     }
                     Signal {
                         name: "transformOriginChanged"
                         Parameter { type: "TransformOrigin" }
                     }
                     Signal {
                         name: "smoothChanged"
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "antialiasingChanged"
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "clipChanged"
                         Parameter { type: "bool" }
                     }
                     Signal {
                         name: "windowChanged"
                         revision: 1
                         Parameter { name: "window"; type: "QQuickWindow"; isPointer: true }
                     }
                     Method { name: "update" }
                     Method {
                         name: "grabToImage"
                         revision: 2
                         type: "bool"
                         Parameter { name: "callback"; type: "QJSValue" }
                         Parameter { name: "targetSize"; type: "QSize" }
                     }
                     Method {
                         name: "grabToImage"
                         revision: 2
                         type: "bool"
                         Parameter { name: "callback"; type: "QJSValue" }
                     }
                     Method {
                         name: "contains"
                         type: "bool"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Method {
                         name: "mapFromItem"
                         Parameter { type: "QQmlV4Function"; isPointer: true }
                     }
                     Method {
                         name: "mapToItem"
                         Parameter { type: "QQmlV4Function"; isPointer: true }
                     }
                     Method { name: "forceActiveFocus" }
                     Method {
                         name: "forceActiveFocus"
                         Parameter { name: "reason"; type: "Qt::FocusReason" }
                     }
                     Method {
                         name: "nextItemInFocusChain"
                         revision: 1
                         type: "QQuickItem*"
                         Parameter { name: "forward"; type: "bool" }
                     }
                     Method { name: "nextItemInFocusChain"; revision: 1; type: "QQuickItem*" }
                     Method {
                         name: "childAt"
                         type: "QQuickItem*"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                 }
                 Component {
                     name: "QQuickPaintedItem"
                     defaultProperty: "data"
                     prototype: "QQuickItem"
                     Enum {
                         name: "RenderTarget"
                         values: {
                             "Image": 0,
                             "FramebufferObject": 1,
                             "InvertedYFramebufferObject": 2
                         }
                     }
                     Property { name: "contentsSize"; type: "QSize" }
                     Property { name: "fillColor"; type: "QColor" }
                     Property { name: "contentsScale"; type: "double" }
                     Property { name: "renderTarget"; type: "RenderTarget" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeAreaSeries"
                     prototype: "QtCharts::QAreaSeries"
                     exports: [
                         "QtCharts/AreaSeries 1.0",
                         "QtCharts/AreaSeries 1.1",
                         "QtCharts/AreaSeries 1.2",
                         "QtCharts/AreaSeries 1.3",
                         "QtCharts/AreaSeries 1.4",
                         "QtCharts/AreaSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4, 4]
                     Property { name: "upperSeries"; type: "DeclarativeLineSeries"; isPointer: true }
                     Property { name: "lowerSeries"; type: "DeclarativeLineSeries"; isPointer: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "brushFilename"; revision: 4; type: "string" }
                     Property { name: "brush"; revision: 4; type: "QBrush" }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal { name: "brushChanged"; revision: 4 }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 4
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeAxes"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/DeclarativeAxes 1.0",
                         "QtCharts/DeclarativeAxes 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; type: "QAbstractAxis"; isPointer: true }
                     Signal {
                         name: "axisXChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QBarSeries"
                     exports: [
                         "QtCharts/BarSeries 1.0",
                         "QtCharts/BarSeries 1.1",
                         "QtCharts/BarSeries 1.2",
                         "QtCharts/BarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBarSet"
                     prototype: "QtCharts::QBarSet"
                     exports: [
                         "QtCharts/BarSet 1.0",
                         "QtCharts/BarSet 1.1",
                         "QtCharts/BarSet 1.4",
                         "QtCharts/BarSet 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 2, 2]
                     Property { name: "values"; type: "QVariantList" }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "brushFilename"; revision: 2; type: "string" }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 2
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "at"
                         type: "double"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBoxPlotSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QBoxPlotSeries"
                     exports: [
                         "QtCharts/BoxPlotSeries 1.3",
                         "QtCharts/BoxPlotSeries 1.4",
                         "QtCharts/BoxPlotSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 1]
                     Property { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "brushFilename"; revision: 1; type: "string" }
                     Signal {
                         name: "axisXChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "clicked"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 1
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "onHovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onPressed"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onReleased"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onDoubleClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "box"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "box"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBoxSet"
                     prototype: "QtCharts::QBoxSet"
                     exports: [
                         "QtCharts/BoxSet 1.3",
                         "QtCharts/BoxSet 1.4",
                         "QtCharts/BoxSet 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 1]
                     Enum {
                         name: "ValuePositions"
                         values: {
                             "LowerExtreme": 0,
                             "LowerQuartile": 1,
                             "Median": 2,
                             "UpperQuartile": 3,
                             "UpperExtreme": 4
                         }
                     }
                     Property { name: "values"; type: "QVariantList" }
                     Property { name: "label"; type: "string" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "brushFilename"; revision: 1; type: "string" }
                     Signal { name: "changedValues" }
                     Signal {
                         name: "changedValue"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 1
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "value"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "double"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "setValue"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "value"; type: "double" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeCategoryAxis"
                     defaultProperty: "axisChildren"
                     prototype: "QtCharts::QCategoryAxis"
                     exports: [
                         "QtCharts/CategoryAxis 1.1",
                         "QtCharts/CategoryAxis 2.0",
                         "QtCharts/CategoryAxis 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 0, 1]
                     Enum {
                         name: "AxisLabelsPosition"
                         values: {
                             "AxisLabelsPositionCenter": 0,
                             "AxisLabelsPositionOnValue": 1
                         }
                     }
                     Property { name: "axisChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "labelsPosition"; revision: 1; type: "AxisLabelsPosition" }
                     Signal {
                         name: "labelsPositionChanged"
                         revision: 1
                         Parameter { name: "position"; type: "AxisLabelsPosition" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "categoryEndValue"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "label"; type: "string" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldLabel"; type: "string" }
                         Parameter { name: "newLabel"; type: "string" }
                     }
                     Method {
                         name: "appendAxisChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeCategoryRange"
                     prototype: "QObject"
                     exports: ["QtCharts/CategoryRange 1.1", "QtCharts/CategoryRange 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "endValue"; type: "double" }
                     Property { name: "label"; type: "string" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeChart"
                     defaultProperty: "data"
                     prototype: "QQuickPaintedItem"
                     exports: [
                         "QtCharts/ChartView 1.0",
                         "QtCharts/ChartView 1.1",
                         "QtCharts/ChartView 1.2",
                         "QtCharts/ChartView 1.3",
                         "QtCharts/ChartView 2.0",
                         "QtCharts/ChartView 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4, 5]
                     Enum {
                         name: "Theme"
                         values: {
                             "ChartThemeLight": 0,
                             "ChartThemeBlueCerulean": 1,
                             "ChartThemeDark": 2,
                             "ChartThemeBrownSand": 3,
                             "ChartThemeBlueNcs": 4,
                             "ChartThemeHighContrast": 5,
                             "ChartThemeBlueIcy": 6,
                             "ChartThemeQt": 7
                         }
                     }
                     Enum {
                         name: "Animation"
                         values: {
                             "NoAnimation": 0,
                             "GridAxisAnimations": 1,
                             "SeriesAnimations": 2,
                             "AllAnimations": 3
                         }
                     }
                     Enum {
                         name: "SeriesType"
                         values: {
                             "SeriesTypeLine": 0,
                             "SeriesTypeArea": 1,
                             "SeriesTypeBar": 2,
                             "SeriesTypeStackedBar": 3,
                             "SeriesTypePercentBar": 4,
                             "SeriesTypeBoxPlot": 5,
                             "SeriesTypePie": 6,
                             "SeriesTypeScatter": 7,
                             "SeriesTypeSpline": 8,
                             "SeriesTypeHorizontalBar": 9,
                             "SeriesTypeHorizontalStackedBar": 10,
                             "SeriesTypeHorizontalPercentBar": 11
                         }
                     }
                     Property { name: "theme"; type: "Theme" }
                     Property { name: "animationOptions"; type: "Animation" }
                     Property { name: "animationDuration"; revision: 5; type: "int" }
                     Property { name: "animationEasingCurve"; revision: 5; type: "QEasingCurve" }
                     Property { name: "title"; type: "string" }
                     Property { name: "titleFont"; type: "QFont" }
                     Property { name: "titleColor"; type: "QColor" }
                     Property { name: "legend"; type: "QLegend"; isReadonly: true; isPointer: true }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "backgroundColor"; type: "QColor" }
                     Property { name: "dropShadowEnabled"; type: "bool" }
                     Property { name: "backgroundRoundness"; revision: 3; type: "double" }
                     Property {
                         name: "margins"
                         revision: 2
                         type: "DeclarativeMargins"
                         isReadonly: true
                         isPointer: true
                     }
                     Property { name: "plotArea"; revision: 1; type: "QRectF"; isReadonly: true }
                     Property { name: "plotAreaColor"; revision: 3; type: "QColor" }
                     Property { name: "axes"; revision: 2; type: "QAbstractAxis"; isList: true; isReadonly: true }
                     Property { name: "localizeNumbers"; revision: 4; type: "bool" }
                     Property { name: "locale"; revision: 4; type: "QLocale" }
                     Signal { name: "axisLabelsChanged" }
                     Signal {
                         name: "titleColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "dropShadowEnabledChanged"
                         Parameter { name: "enabled"; type: "bool" }
                     }
                     Signal { name: "marginsChanged"; revision: 2 }
                     Signal {
                         name: "plotAreaChanged"
                         Parameter { name: "plotArea"; type: "QRectF" }
                     }
                     Signal {
                         name: "seriesAdded"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Signal {
                         name: "seriesRemoved"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Signal { name: "plotAreaColorChanged"; revision: 3 }
                     Signal {
                         name: "backgroundRoundnessChanged"
                         revision: 3
                         Parameter { name: "diameter"; type: "double" }
                     }
                     Signal { name: "localizeNumbersChanged"; revision: 4 }
                     Signal { name: "localeChanged"; revision: 4 }
                     Signal {
                         name: "animationDurationChanged"
                         revision: 5
                         Parameter { name: "msecs"; type: "int" }
                     }
                     Signal {
                         name: "animationEasingCurveChanged"
                         revision: 5
                         Parameter { name: "curve"; type: "QEasingCurve" }
                     }
                     Method {
                         name: "series"
                         type: "QAbstractSeries*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "series"
                         type: "QAbstractSeries*"
                         Parameter { name: "seriesName"; type: "string" }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                         Parameter { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                         Parameter { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                     }
                     Method {
                         name: "removeSeries"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "removeAllSeries" }
                     Method {
                         name: "setAxisX"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "setAxisX"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "setAxisY"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "setAxisY"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "axisX"
                         type: "QAbstractAxis*"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "axisX"; type: "QAbstractAxis*" }
                     Method {
                         name: "axisY"
                         type: "QAbstractAxis*"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "axisY"; type: "QAbstractAxis*" }
                     Method {
                         name: "zoom"
                         Parameter { name: "factor"; type: "double" }
                     }
                     Method { name: "zoomIn"; revision: 5 }
                     Method {
                         name: "zoomIn"
                         revision: 5
                         Parameter { name: "rectangle"; type: "QRectF" }
                     }
                     Method { name: "zoomOut"; revision: 5 }
                     Method { name: "zoomReset"; revision: 5 }
                     Method {
                         name: "scrollLeft"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollRight"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollUp"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollDown"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "mapToValue"
                         revision: 5
                         type: "QPointF"
                         Parameter { name: "position"; type: "QPointF" }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "mapToValue"
                         revision: 5
                         type: "QPointF"
                         Parameter { name: "position"; type: "QPointF" }
                     }
                     Method {
                         name: "mapToPosition"
                         revision: 5
                         type: "QPointF"
                         Parameter { name: "value"; type: "QPointF" }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "mapToPosition"
                         revision: 5
                         type: "QPointF"
                         Parameter { name: "value"; type: "QPointF" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalBarSeries"
                     exports: [
                         "QtCharts/HorizontalBarSeries 1.1",
                         "QtCharts/HorizontalBarSeries 1.2",
                         "QtCharts/HorizontalBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalPercentBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalPercentBarSeries"
                     exports: [
                         "QtCharts/HorizontalPercentBarSeries 1.1",
                         "QtCharts/HorizontalPercentBarSeries 1.2",
                         "QtCharts/HorizontalPercentBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalStackedBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalStackedBarSeries"
                     exports: [
                         "QtCharts/HorizontalStackedBarSeries 1.1",
                         "QtCharts/HorizontalStackedBarSeries 1.2",
                         "QtCharts/HorizontalStackedBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeLineSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QLineSeries"
                     exports: [
                         "QtCharts/LineSeries 1.0",
                         "QtCharts/LineSeries 1.1",
                         "QtCharts/LineSeries 1.2",
                         "QtCharts/LineSeries 1.3",
                         "QtCharts/LineSeries 2.0",
                         "QtCharts/LineSeries 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 3, 4]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "width"; revision: 1; type: "double" }
                     Property { name: "style"; revision: 1; type: "Qt::PenStyle" }
                     Property { name: "capStyle"; revision: 1; type: "Qt::PenCapStyle" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "widthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "styleChanged"
                         revision: 1
                         Parameter { name: "style"; type: "Qt::PenStyle" }
                     }
                     Signal {
                         name: "capStyleChanged"
                         revision: 1
                         Parameter { name: "capStyle"; type: "Qt::PenCapStyle" }
                     }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "removePoints"
                         revision: 4
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeMargins"
                     prototype: "QObject"
                     exports: ["QtCharts/Margins 1.1", "QtCharts/Margins 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "top"; type: "int" }
                     Property { name: "bottom"; type: "int" }
                     Property { name: "left"; type: "int" }
                     Property { name: "right"; type: "int" }
                     Signal {
                         name: "topChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "bottomChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "leftChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "rightChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativePercentBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QPercentBarSeries"
                     exports: [
                         "QtCharts/PercentBarSeries 1.0",
                         "QtCharts/PercentBarSeries 1.1",
                         "QtCharts/PercentBarSeries 1.2",
                         "QtCharts/PercentBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativePieSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QPieSeries"
                     exports: [
                         "QtCharts/PieSeries 1.0",
                         "QtCharts/PieSeries 1.1",
                         "QtCharts/PieSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "sliceAdded"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "sliceRemoved"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleAdded"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Method {
                         name: "handleRemoved"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Method {
                         name: "at"
                         type: "QPieSlice*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "find"
                         type: "QPieSlice*"
                         Parameter { name: "label"; type: "string" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativePieSlice*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativePieSlice"
                     prototype: "QtCharts::QPieSlice"
                     exports: ["QtCharts/PieSlice 1.4", "QtCharts/PieSlice 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "brushFilename"; type: "string" }
                     Signal {
                         name: "brushFilenameChanged"
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativePolarChart"
                     defaultProperty: "data"
                     prototype: "QtCharts::DeclarativeChart"
                     exports: [
                         "QtCharts/PolarChartView 1.3",
                         "QtCharts/PolarChartView 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 1]
                 }
                 Component {
                     name: "QtCharts::DeclarativeScatterSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QScatterSeries"
                     exports: [
                         "QtCharts/ScatterSeries 1.0",
                         "QtCharts/ScatterSeries 1.1",
                         "QtCharts/ScatterSeries 1.2",
                         "QtCharts/ScatterSeries 1.3",
                         "QtCharts/ScatterSeries 1.4",
                         "QtCharts/ScatterSeries 2.0",
                         "QtCharts/ScatterSeries 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4, 4, 5]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "brushFilename"; revision: 4; type: "string" }
                     Property { name: "brush"; revision: 4; type: "QBrush" }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 4
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Signal { name: "brushChanged"; revision: 4 }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "removePoints"
                         revision: 5
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeSplineSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QSplineSeries"
                     exports: [
                         "QtCharts/SplineSeries 1.0",
                         "QtCharts/SplineSeries 1.1",
                         "QtCharts/SplineSeries 1.2",
                         "QtCharts/SplineSeries 1.3",
                         "QtCharts/SplineSeries 2.0",
                         "QtCharts/SplineSeries 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 3, 4]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "width"; revision: 1; type: "double" }
                     Property { name: "style"; revision: 1; type: "Qt::PenStyle" }
                     Property { name: "capStyle"; revision: 1; type: "Qt::PenCapStyle" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "widthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "styleChanged"
                         revision: 1
                         Parameter { name: "style"; type: "Qt::PenStyle" }
                     }
                     Signal {
                         name: "capStyleChanged"
                         revision: 1
                         Parameter { name: "capStyle"; type: "Qt::PenCapStyle" }
                     }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "removePoints"
                         revision: 4
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeStackedBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QStackedBarSeries"
                     exports: [
                         "QtCharts/StackedBarSeries 1.0",
                         "QtCharts/StackedBarSeries 1.1",
                         "QtCharts/StackedBarSeries 1.2",
                         "QtCharts/StackedBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeXYPoint"
                     prototype: "QObject"
                     exports: ["QtCharts/XYPoint 1.0", "QtCharts/XYPoint 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "x"; type: "double" }
                     Property { name: "y"; type: "double" }
                 }
                 Component {
                     name: "QtCharts::LegendScroller"
                     defaultProperty: "children"
                     prototype: "QtCharts::QLegend"
                 }
                 Component {
                     name: "QtCharts::QAbstractAxis"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/AbstractAxis 1.0",
                         "QtCharts/AbstractAxis 2.0",
                         "QtCharts/AbstractAxis 2.1"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "visible"; type: "bool" }
                     Property { name: "lineVisible"; type: "bool" }
                     Property { name: "linePen"; type: "QPen" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "labelsVisible"; type: "bool" }
                     Property { name: "labelsBrush"; type: "QBrush" }
                     Property { name: "labelsAngle"; type: "int" }
                     Property { name: "labelsFont"; type: "QFont" }
                     Property { name: "labelsColor"; type: "QColor" }
                     Property { name: "gridVisible"; type: "bool" }
                     Property { name: "gridLinePen"; type: "QPen" }
                     Property { name: "minorGridVisible"; type: "bool" }
                     Property { name: "minorGridLinePen"; type: "QPen" }
+                    Property { name: "gridLineColor"; type: "QColor" }
+                    Property { name: "minorGridLineColor"; type: "QColor" }
                     Property { name: "shadesVisible"; type: "bool" }
                     Property { name: "shadesColor"; type: "QColor" }
                     Property { name: "shadesBorderColor"; type: "QColor" }
                     Property { name: "shadesPen"; type: "QPen" }
                     Property { name: "shadesBrush"; type: "QBrush" }
                     Property { name: "titleText"; type: "string" }
                     Property { name: "titleBrush"; type: "QBrush" }
                     Property { name: "titleVisible"; type: "bool" }
                     Property { name: "titleFont"; type: "QFont" }
                     Property { name: "orientation"; type: "Qt::Orientation"; isReadonly: true }
                     Property { name: "alignment"; type: "Qt::Alignment"; isReadonly: true }
                     Property { name: "reverse"; type: "bool" }
                     Signal {
                         name: "visibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "linePenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "lineVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "labelsVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "labelsBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
                     Signal {
                         name: "labelsFontChanged"
                         Parameter { name: "pen"; type: "QFont" }
                     }
                     Signal {
                         name: "labelsAngleChanged"
                         Parameter { name: "angle"; type: "int" }
                     }
                     Signal {
                         name: "gridLinePenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "gridVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "minorGridVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "minorGridLinePenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
+                        name: "gridLineColorChanged"
+                        Parameter { name: "color"; type: "QColor" }
+                    }
+                    Signal {
+                        name: "minorGridLineColorChanged"
+                        Parameter { name: "color"; type: "QColor" }
+                    }
+                    Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "labelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "titleTextChanged"
                         Parameter { name: "title"; type: "string" }
                     }
                     Signal {
                         name: "titleBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
                     Signal {
                         name: "titleVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "titleFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "shadesVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "shadesColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "shadesBorderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "shadesPenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "shadesBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
                     Signal {
                         name: "reverseChanged"
                         Parameter { name: "reverse"; type: "bool" }
                     }
                 }
                 Component {
                     name: "QtCharts::QAbstractBarSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: [
                         "QtCharts/AbstractBarSeries 1.0",
                         "QtCharts/AbstractBarSeries 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "LabelsPosition"
                         values: {
                             "LabelsCenter": 0,
                             "LabelsInsideEnd": 1,
                             "LabelsInsideBase": 2,
                             "LabelsOutsideEnd": 3
                         }
                     }
                     Property { name: "barWidth"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "labelsVisible"; type: "bool" }
                     Property { name: "labelsFormat"; type: "string" }
                     Property { name: "labelsPosition"; type: "LabelsPosition" }
                     Property { name: "labelsAngle"; type: "double" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "labelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "labelsPositionChanged"
                         Parameter { name: "position"; type: "QAbstractBarSeries::LabelsPosition" }
                     }
                     Signal {
                         name: "labelsAngleChanged"
                         Parameter { name: "angle"; type: "double" }
                     }
                     Signal {
                         name: "barsetsAdded"
                         Parameter { name: "sets"; type: "QList<QBarSet*>" }
                     }
                     Signal {
                         name: "barsetsRemoved"
                         Parameter { name: "sets"; type: "QList<QBarSet*>" }
                     }
                 }
                 Component {
                     name: "QtCharts::QAbstractSeries"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/AbstractSeries 1.0",
                         "QtCharts/AbstractSeries 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "SeriesType"
                         values: {
                             "SeriesTypeLine": 0,
                             "SeriesTypeArea": 1,
                             "SeriesTypeBar": 2,
                             "SeriesTypeStackedBar": 3,
                             "SeriesTypePercentBar": 4,
                             "SeriesTypePie": 5,
                             "SeriesTypeScatter": 6,
                             "SeriesTypeSpline": 7,
                             "SeriesTypeHorizontalBar": 8,
                             "SeriesTypeHorizontalStackedBar": 9,
                             "SeriesTypeHorizontalPercentBar": 10,
                             "SeriesTypeBoxPlot": 11
                         }
                     }
                     Property { name: "name"; type: "string" }
                     Property { name: "visible"; type: "bool" }
                     Property { name: "opacity"; type: "double" }
                     Property { name: "type"; type: "SeriesType"; isReadonly: true }
                 }
                 Component {
                     name: "QtCharts::QAreaSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     Property { name: "upperSeries"; type: "QLineSeries"; isReadonly: true; isPointer: true }
                     Property { name: "lowerSeries"; type: "QLineSeries"; isReadonly: true; isPointer: true }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "pointLabelsFormat"; type: "string" }
                     Property { name: "pointLabelsVisible"; type: "bool" }
                     Property { name: "pointLabelsFont"; type: "QFont" }
                     Property { name: "pointLabelsColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "point"; type: "QPointF" }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal { name: "selected" }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "pointLabelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "pointLabelsVisibilityChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "pointLabelsFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "pointLabelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBarCategoryAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: [
                         "QtCharts/BarCategoriesAxis 1.0",
                         "QtCharts/BarCategoryAxis 1.1",
                         "QtCharts/BarCategoryAxis 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "categories"; type: "QStringList" }
                     Property { name: "min"; type: "string" }
                     Property { name: "max"; type: "string" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "string" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "string" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "string" }
                         Parameter { name: "max"; type: "string" }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::QBarModelMapper"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/BarModelMapper 1.0",
                         "QtCharts/BarModelMapper 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component { name: "QtCharts::QBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QBarSet"
                     prototype: "QObject"
                     exports: ["QtCharts/BarSetBase 1.0", "QtCharts/BarSetBase 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "label"; type: "string" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "labelBrush"; type: "QBrush" }
                     Property { name: "labelFont"; type: "QFont" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "labelColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "labelColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "valuesAdded"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "valuesRemoved"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "valueChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBoxPlotModelMapper"
                     prototype: "QObject"
                     exports: ["QtCharts/BoxPlotModelMapper 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0]
                 }
                 Component {
                     name: "QtCharts::QBoxPlotSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     Property { name: "boxOutlineVisible"; type: "bool" }
                     Property { name: "boxWidth"; type: "double" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "count"; revision: 1; type: "int"; isReadonly: true }
                     Signal {
                         name: "clicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal { name: "boxOutlineVisibilityChanged" }
                     Signal {
                         name: "boxsetsAdded"
                         Parameter { name: "sets"; type: "QList<QBoxSet*>" }
                     }
                     Signal {
                         name: "boxsetsRemoved"
                         Parameter { name: "sets"; type: "QList<QBoxSet*>" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBoxSet"
                     prototype: "QObject"
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Signal { name: "clicked" }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                     }
                     Signal { name: "pressed" }
                     Signal { name: "released" }
                     Signal { name: "doubleClicked" }
                     Signal { name: "valuesChanged" }
                     Signal {
                         name: "valueChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal { name: "cleared" }
                 }
                 Component {
                     name: "QtCharts::QCategoryAxis"
                     prototype: "QtCharts::QValueAxis"
                     Enum {
                         name: "AxisLabelsPosition"
                         values: {
                             "AxisLabelsPositionCenter": 0,
                             "AxisLabelsPositionOnValue": 1
                         }
                     }
                     Property { name: "startValue"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "categoriesLabels"; type: "QStringList"; isReadonly: true }
                     Property { name: "labelsPosition"; type: "AxisLabelsPosition" }
                     Signal { name: "categoriesChanged" }
                     Signal {
                         name: "labelsPositionChanged"
                         Parameter { name: "position"; type: "QCategoryAxis::AxisLabelsPosition" }
                     }
                 }
                 Component {
                     name: "QtCharts::QDateTimeAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: ["QtCharts/DateTimeAxis 1.1", "QtCharts/DateTimeAxis 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "tickCount"; type: "int" }
                     Property { name: "min"; type: "QDateTime" }
                     Property { name: "max"; type: "QDateTime" }
                     Property { name: "format"; type: "string" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "QDateTime" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "QDateTime" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "QDateTime" }
                         Parameter { name: "max"; type: "QDateTime" }
                     }
                     Signal {
                         name: "formatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "tickCountChanged"
                         Parameter { name: "tick"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::QHBarModelMapper"
                     prototype: "QtCharts::QBarModelMapper"
                     exports: [
                         "QtCharts/HBarModelMapper 1.0",
                         "QtCharts/HBarModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QAbstractBarSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBarSetRow"; type: "int" }
                     Property { name: "lastBarSetRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QHPieModelMapper"
                     prototype: "QtCharts::QPieModelMapper"
                     exports: [
                         "QtCharts/HPieModelMapper 1.0",
                         "QtCharts/HPieModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QPieSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "valuesRow"; type: "int" }
                     Property { name: "labelsRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QHXYModelMapper"
                     prototype: "QtCharts::QXYModelMapper"
                     exports: [
                         "QtCharts/HXYModelMapper 1.0",
                         "QtCharts/HXYModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QXYSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "xRow"; type: "int" }
                     Property { name: "yRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component { name: "QtCharts::QHorizontalBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QHorizontalPercentBarSeries"
                     prototype: "QtCharts::QAbstractBarSeries"
                 }
                 Component {
                     name: "QtCharts::QHorizontalStackedBarSeries"
                     prototype: "QtCharts::QAbstractBarSeries"
                 }
                 Component {
                     name: "QtCharts::QLegend"
                     defaultProperty: "children"
                     prototype: "QGraphicsWidget"
                     exports: ["QtCharts/Legend 1.0", "QtCharts/Legend 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "alignment"; type: "Qt::Alignment" }
                     Property { name: "backgroundVisible"; type: "bool" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "font"; type: "QFont" }
                     Property { name: "labelColor"; type: "QColor" }
                     Property { name: "reverseMarkers"; type: "bool" }
                     Signal {
                         name: "backgroundVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "fontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "labelColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "reverseMarkersChanged"
                         Parameter { name: "reverseMarkers"; type: "bool" }
                     }
                 }
                 Component { name: "QtCharts::QLineSeries"; prototype: "QtCharts::QXYSeries" }
                 Component {
                     name: "QtCharts::QLogValueAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: ["QtCharts/LogValueAxis 1.3", "QtCharts/LogValueAxis 2.0"]
                     exportMetaObjectRevisions: [0, 1]
                     Property { name: "min"; type: "double" }
                     Property { name: "max"; type: "double" }
                     Property { name: "labelFormat"; type: "string" }
                     Property { name: "base"; type: "double" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "double" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "double" }
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "labelFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "baseChanged"
                         Parameter { name: "base"; type: "double" }
                     }
                 }
                 Component { name: "QtCharts::QPercentBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QPieModelMapper"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/PieModelMapper 1.0",
                         "QtCharts/PieModelMapper 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component {
                     name: "QtCharts::QPieSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: ["QtCharts/QPieSeries 1.0", "QtCharts/QPieSeries 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "horizontalPosition"; type: "double" }
                     Property { name: "verticalPosition"; type: "double" }
                     Property { name: "size"; type: "double" }
                     Property { name: "startAngle"; type: "double" }
                     Property { name: "endAngle"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "sum"; type: "double"; isReadonly: true }
                     Property { name: "holeSize"; type: "double" }
                     Signal {
                         name: "added"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Signal {
                         name: "removed"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Signal {
                         name: "clicked"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::QPieSlice"
                     prototype: "QObject"
                     exports: ["QtCharts/PieSlice 1.0", "QtCharts/PieSlice 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "LabelPosition"
                         values: {
                             "LabelOutside": 0,
                             "LabelInsideHorizontal": 1,
                             "LabelInsideTangential": 2,
                             "LabelInsideNormal": 3
                         }
                     }
                     Property { name: "label"; type: "string" }
                     Property { name: "value"; type: "double" }
                     Property { name: "labelVisible"; type: "bool" }
                     Property { name: "labelPosition"; type: "LabelPosition" }
                     Property { name: "exploded"; type: "bool" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "borderWidth"; type: "int" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "labelBrush"; type: "QBrush" }
                     Property { name: "labelColor"; type: "QColor" }
                     Property { name: "labelFont"; type: "QFont" }
                     Property { name: "labelArmLengthFactor"; type: "double" }
                     Property { name: "explodeDistanceFactor"; type: "double" }
                     Property { name: "percentage"; type: "double"; isReadonly: true }
                     Property { name: "startAngle"; type: "double"; isReadonly: true }
                     Property { name: "angleSpan"; type: "double"; isReadonly: true }
                     Signal { name: "clicked" }
                     Signal {
                         name: "hovered"
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal { name: "pressed" }
                     Signal { name: "released" }
                     Signal { name: "doubleClicked" }
                 }
                 Component {
                     name: "QtCharts::QScatterSeries"
                     prototype: "QtCharts::QXYSeries"
                     Enum {
                         name: "MarkerShape"
                         values: {
                             "MarkerShapeCircle": 0,
                             "MarkerShapeRectangle": 1
                         }
                     }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "markerShape"; type: "MarkerShape" }
                     Property { name: "markerSize"; type: "double" }
                     Property { name: "brush"; type: "QBrush" }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                 }
                 Component { name: "QtCharts::QSplineSeries"; prototype: "QtCharts::QLineSeries" }
                 Component { name: "QtCharts::QStackedBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QVBarModelMapper"
                     prototype: "QtCharts::QBarModelMapper"
                     exports: [
                         "QtCharts/VBarModelMapper 1.0",
                         "QtCharts/VBarModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QAbstractBarSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBarSetColumn"; type: "int" }
                     Property { name: "lastBarSetColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVBoxPlotModelMapper"
                     prototype: "QtCharts::QBoxPlotModelMapper"
                     exports: ["QtCharts/VBoxPlotModelMapper 2.0"]
                     exportMetaObjectRevisions: [0]
                     Property { name: "series"; type: "QBoxPlotSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBoxSetColumn"; type: "int" }
                     Property { name: "lastBoxSetColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVPieModelMapper"
                     prototype: "QtCharts::QPieModelMapper"
                     exports: [
                         "QtCharts/VPieModelMapper 1.0",
                         "QtCharts/VPieModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QPieSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "valuesColumn"; type: "int" }
                     Property { name: "labelsColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVXYModelMapper"
                     prototype: "QtCharts::QXYModelMapper"
                     exports: [
                         "QtCharts/VXYModelMapper 1.0",
                         "QtCharts/VXYModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QXYSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "xColumn"; type: "int" }
                     Property { name: "yColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QValueAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: [
                         "QtCharts/ValueAxis 1.1",
                         "QtCharts/ValueAxis 2.0",
                         "QtCharts/ValuesAxis 1.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "tickCount"; type: "int" }
                     Property { name: "min"; type: "double" }
                     Property { name: "max"; type: "double" }
                     Property { name: "labelFormat"; type: "string" }
                     Property { name: "minorTickCount"; type: "int" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "double" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "double" }
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "tickCountChanged"
                         Parameter { name: "tickCount"; type: "int" }
                     }
                     Signal {
                         name: "minorTickCountChanged"
                         Parameter { name: "tickCount"; type: "int" }
                     }
                     Signal {
                         name: "labelFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Method { name: "applyNiceNumbers" }
                 }
                 Component {
                     name: "QtCharts::QXYModelMapper"
                     prototype: "QObject"
                     exports: ["QtCharts/XYModelMapper 1.0", "QtCharts/XYModelMapper 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component {
                     name: "QtCharts::QXYSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: ["QtCharts/XYSeries 1.0", "QtCharts/XYSeries 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "pointsVisible"; type: "bool" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "pointLabelsFormat"; type: "string" }
                     Property { name: "pointLabelsVisible"; type: "bool" }
                     Property { name: "pointLabelsFont"; type: "QFont" }
                     Property { name: "pointLabelsColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "point"; type: "QPointF" }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "pointReplaced"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pointRemoved"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pointAdded"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal { name: "pointsReplaced" }
                     Signal {
                         name: "pointLabelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "pointLabelsVisibilityChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "pointLabelsFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "pointLabelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "pointsRemoved"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                 }
             }

tests/auto/qabstractaxis/tst_qabstractaxis.cpp +164 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "tst_qabstractaxis.h"
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(Qt::Orientation)
             void tst_QAbstractAxis::initTestCase()
             {
             }
             void tst_QAbstractAxis::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QAbstractAxis::init(QAbstractAxis* axis, QAbstractSeries* series)
             {
                 m_axis = axis;
                 m_series = series;
                 m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }
             void tst_QAbstractAxis::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
                 m_axis = 0;
             }
             void tst_QAbstractAxis::qabstractaxis()
             {
                 QCOMPARE(m_axis->linePen(), QPen());
                 QCOMPARE(m_axis->gridLinePen(), QPen());
                 QCOMPARE(m_axis->isLineVisible(), true);
                 QCOMPARE(m_axis->isGridLineVisible(), true);
                 QCOMPARE(m_axis->isVisible(), true);
                 QCOMPARE(m_axis->labelsAngle(), 0);
                 QCOMPARE(m_axis->labelsBrush(), QBrush());
                 QCOMPARE(m_axis->labelsFont(), QFont());
                 QCOMPARE(m_axis->labelsVisible(), true);
                 QCOMPARE(m_axis->orientation(), Qt::Orientation(0));
                 QCOMPARE(m_axis->minorGridLinePen(), QPen());
                 QCOMPARE(m_axis->isMinorGridLineVisible(), true);
                 m_axis->setLineVisible(false);
                 m_axis->setLinePen(QPen());
                 m_axis->setLinePenColor(QColor());
                 m_axis->setGridLinePen(QPen());
                 m_axis->setGridLineVisible(false);
+                m_axis->setGridLineColor(QColor());
+                m_axis->setMinorGridLineColor(QColor());
                 m_axis->setLabelsAngle(-1);
                 m_axis->setLabelsBrush(QBrush());
                 m_axis->setLabelsColor(QColor());
                 m_axis->setLabelsFont(QFont());
                 m_axis->setLabelsVisible(false);
                 m_axis->setMax(QVariant());
                 m_axis->setMin(QVariant());
                 m_axis->setRange(QVariant(), QVariant());
                 m_axis->setShadesBorderColor(QColor());
                 m_axis->setShadesBrush(QBrush());
                 m_axis->setShadesColor(QColor());
                 m_axis->setShadesPen(QPen());
                 m_axis->setShadesVisible(false);
                 m_axis->setVisible(false);
                 m_axis->setMinorGridLinePen(QPen());
                 m_axis->setMinorGridLineVisible(false);
                 //TODO QCOMPARE(m_axis->shadesBrush(), QBrush());
                 QCOMPARE(m_axis->shadesPen(), QPen());
                 QCOMPARE(m_axis->shadesVisible(), false);
                 m_axis->show();
                 m_axis->hide();
             }
             void tst_QAbstractAxis::axisPen_data()
             {
                 QTest::addColumn<QPen>("axisPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::axisPen()
             {
                 QFETCH(QPen, axisPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLinePen(axisPen);
                 QCOMPARE(m_axis->linePen(), axisPen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->axisPen(), axisPen);
             }
             void tst_QAbstractAxis::axisPenColor_data()
             {
             }
             void tst_QAbstractAxis::axisPenColor()
             {
                 QSKIP("Test is not implemented. This is deprecated function");
             }
             void tst_QAbstractAxis::gridLinePen_data()
             {
                 QTest::addColumn<QPen>("gridLinePen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::gridLinePen()
             {
                 QFETCH(QPen, gridLinePen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+                QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setGridLinePen(gridLinePen);
                 QCOMPARE(m_axis->gridLinePen(), gridLinePen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
+                QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->gridLinePen(), gridLinePen);
             }
             void tst_QAbstractAxis::minorGridLinePen_data()
             {
                 QTest::addColumn<QPen>("minorGridLinePen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::minorGridLinePen()
             {
                 QFETCH(QPen, minorGridLinePen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setMinorGridLinePen(minorGridLinePen);
                 QCOMPARE(m_axis->minorGridLinePen(), minorGridLinePen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QAbstractAxis::lineVisible_data()
             {
                 QTest::addColumn<bool>("lineVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::lineVisible()
             {
                 QFETCH(bool, lineVisible);
                 m_axis->setLineVisible(!lineVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLineVisible(lineVisible);
                 QCOMPARE(m_axis->isLineVisible(), lineVisible);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isLineVisible(), lineVisible);
             }
             void tst_QAbstractAxis::gridLineVisible_data()
             {
                 QTest::addColumn<bool>("gridLineVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::gridLineVisible()
             {
                 QFETCH(bool, gridLineVisible);
                 m_axis->setGridLineVisible(!gridLineVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+                QSignalSpy spy9(m_axis, SIGNAL(gridLineColorChanged(QColor)));
                 m_axis->setGridLineVisible(gridLineVisible);
                 QCOMPARE(m_axis->isGridLineVisible(), gridLineVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
+                QCOMPARE(spy9.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isGridLineVisible(), gridLineVisible);
             }
             void tst_QAbstractAxis::minorGridLineVisible_data()
             {
                 QTest::addColumn<bool>("minorGridLineVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::minorGridLineVisible()
             {
                 QFETCH(bool, minorGridLineVisible);
                 m_axis->setMinorGridLineVisible(!minorGridLineVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setMinorGridLineVisible(minorGridLineVisible);
                 QCOMPARE(m_axis->isMinorGridLineVisible(), minorGridLineVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 1);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isMinorGridLineVisible(), minorGridLineVisible);
             }
+            void tst_QAbstractAxis::gridLineColor_data()
+            {
+                QTest::addColumn<QColor>("gridLineColor");
+                QTest::newRow("blue") << QColor(Qt::blue);
+                QTest::newRow("red") << QColor(Qt::red);
+                QTest::newRow("yellow") << QColor(Qt::yellow);
+            }
+            void tst_QAbstractAxis::gridLineColor()
+            {
+                QFETCH(QColor, gridLineColor);
+                QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
+                QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
+                QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
+                QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
+                QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
+                QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
+                QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+                QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
+                m_axis->setGridLineColor(gridLineColor);
+                QCOMPARE(m_axis->gridLineColor(), gridLineColor);
+                QCOMPARE(spy0.count(), 0);
+                QCOMPARE(spy1.count(), 0);
+                QCOMPARE(spy2.count(), 0);
+                QCOMPARE(spy3.count(), 0);
+                QCOMPARE(spy4.count(), 0);
+                QCOMPARE(spy5.count(), 0);
+                QCOMPARE(spy6.count(), 0);
+                QCOMPARE(spy7.count(), 0);
+                QCOMPARE(spy8.count(), 0);
+                QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 1);
+                QCOMPARE(spy11.count(), 0);
+                m_chart->setAxisX(m_axis, m_series);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+            }
+            void tst_QAbstractAxis::minorGridLineColor_data()
+            {
+                QTest::addColumn<QColor>("minorGridLineColor");
+                QTest::newRow("blue") << QColor(Qt::blue);
+                QTest::newRow("red") << QColor(Qt::red);
+                QTest::newRow("yellow") << QColor(Qt::yellow);
+            }
+            void tst_QAbstractAxis::minorGridLineColor()
+            {
+                QFETCH(QColor, minorGridLineColor);
+                QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
+                QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
+                QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
+                QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
+                QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
+                QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
+                QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+                QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
+                m_axis->setMinorGridLineColor(minorGridLineColor);
+                QCOMPARE(m_axis->minorGridLineColor(), minorGridLineColor);
+                QCOMPARE(spy0.count(), 0);
+                QCOMPARE(spy1.count(), 0);
+                QCOMPARE(spy2.count(), 0);
+                QCOMPARE(spy3.count(), 0);
+                QCOMPARE(spy4.count(), 0);
+                QCOMPARE(spy5.count(), 0);
+                QCOMPARE(spy6.count(), 0);
+                QCOMPARE(spy7.count(), 0);
+                QCOMPARE(spy8.count(), 0);
+                QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 1);
+                m_chart->setAxisX(m_axis, m_series);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+            }
             void tst_QAbstractAxis::visible_data()
             {
                 QTest::addColumn<bool>("visible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::visible()
             {
                 QFETCH(bool, visible);
                 m_axis->setVisible(!visible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setVisible(visible);
                 QCOMPARE(m_axis->isVisible(), visible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isVisible(), visible);
             }
             void tst_QAbstractAxis::labelsAngle_data()
             {
                 QTest::addColumn<int>("labelsAngle");
                 QTest::newRow("0") << 0;
                 QTest::newRow("45") << 45;
                 QTest::newRow("90") << 90;
             }
             void tst_QAbstractAxis::labelsAngle()
             {
                 QFETCH(int, labelsAngle);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLabelsAngle(labelsAngle);
                 QCOMPARE(m_axis->labelsAngle(), labelsAngle);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsAngle(), labelsAngle);
             }
             void tst_QAbstractAxis::labelsBrush_data()
             {
                 QTest::addColumn<QBrush>("labelsBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QAbstractAxis::labelsBrush()
             {
                 QFETCH(QBrush, labelsBrush);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLabelsBrush(labelsBrush);
                 QCOMPARE(m_axis->labelsBrush(), labelsBrush);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 //TODO QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsBrush(), labelsBrush);
             }
             void tst_QAbstractAxis::labelsColor_data()
             {
             }
             void tst_QAbstractAxis::labelsColor()
             {
                 QSKIP("Test is not implemented. This is deprecated function");
             }
             void tst_QAbstractAxis::labelsFont_data()
             {
                 QTest::addColumn<QFont>("labelsFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("serif") << QFont("SansSerif");
             }
             void tst_QAbstractAxis::labelsFont()
             {
                 QFETCH(QFont, labelsFont);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLabelsFont(labelsFont);
                 QCOMPARE(m_axis->labelsFont(), labelsFont);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsFont(), labelsFont);
             }
             void tst_QAbstractAxis::labelsVisible_data()
             {
                 QTest::addColumn<bool>("labelsVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::labelsVisible()
             {
                 QFETCH(bool, labelsVisible);
                 m_axis->setLabelsVisible(!labelsVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setLabelsVisible(labelsVisible);
                 QCOMPARE(m_axis->labelsVisible(), labelsVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 1);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsVisible(), labelsVisible);
             }
             void tst_QAbstractAxis::orientation_data()
             {
                 QTest::addColumn<Qt::Orientation>("orientation");
                 QTest::newRow("Vertical") << Qt::Vertical;
                 QTest::newRow("Horizontal") << Qt::Horizontal;
             }
             void tst_QAbstractAxis::orientation()
             {
                 QFETCH(Qt::Orientation, orientation);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 if(orientation==Qt::Vertical){
                     m_chart->setAxisY(m_axis,m_series);
                 }else{
                     m_chart->setAxisX(m_axis,m_series);
                 }
                 QCOMPARE(m_axis->orientation(), orientation);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->orientation(), orientation);
             }
             void tst_QAbstractAxis::setMax_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("max");
                 QTest::newRow("something") << QVariant("something");
                 QTest::newRow("1.0") << QVariant(1.0);
             }
             void tst_QAbstractAxis::setMax()
             {
                 QFETCH(QVariant, max);
                 m_axis->setMax(max);
             }
             void tst_QAbstractAxis::setMin_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("min");
                 QTest::newRow("something") << QVariant("something");
                 QTest::newRow("1.0") << QVariant(1.0);
             }
             // public void setMin(QVariant const& min)
             void tst_QAbstractAxis::setMin()
             {
                 QFETCH(QVariant, min);
                 m_axis->setMin(min);
             }
             void tst_QAbstractAxis::setRange_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("min");
                 QTest::addColumn<QVariant>("max");
                 QTest::newRow("something") << QVariant("something0") << QVariant("something1");
                 QTest::newRow("-1 1") << QVariant(-1.0) << QVariant(1.0);
             }
             // public void setRange(QVariant const& min, QVariant const& max)
             void tst_QAbstractAxis::setRange()
             {
                 QFETCH(QVariant, min);
                 QFETCH(QVariant, max);
                 m_axis->setRange(min,max);
             }
             void tst_QAbstractAxis::shadesBorderColor_data()
             {
             }
             void tst_QAbstractAxis::shadesBorderColor()
             {
                 QSKIP("Test is not implemented. This is deprecated function");
             }
             void tst_QAbstractAxis::shadesBrush_data()
             {
                 QTest::addColumn<QBrush>("shadesBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QAbstractAxis::shadesBrush()
             {
                 QFETCH(QBrush, shadesBrush);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setShadesBrush(shadesBrush);
                 QCOMPARE(m_axis->shadesBrush(), shadesBrush);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 //TODO QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesBrush(), shadesBrush);
             }
             void tst_QAbstractAxis::shadesColor_data()
             {
             }
             // public QColor shadesColor() const
             void tst_QAbstractAxis::shadesColor()
             {
                 QSKIP("Test is not implemented. This is deprecated function");
             }
             void tst_QAbstractAxis::shadesPen_data()
             {
                 QTest::addColumn<QPen>("shadesPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::shadesPen()
             {
                 QFETCH(QPen, shadesPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setShadesPen(shadesPen);
                 QCOMPARE(m_axis->shadesPen(), shadesPen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesPen(), shadesPen);
             }
             void tst_QAbstractAxis::shadesVisible_data()
             {
                 QTest::addColumn<bool>("shadesVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::shadesVisible()
             {
                 QFETCH(bool, shadesVisible);
                 m_axis->setShadesVisible(!shadesVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->setShadesVisible(shadesVisible);
                 QCOMPARE(m_axis->shadesVisible(), shadesVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 1);
                 QCOMPARE(spy8.count(), 0);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesVisible(), shadesVisible);
             }
             void tst_QAbstractAxis::show_data()
             {
             }
             void tst_QAbstractAxis::show()
             {
                 m_axis->hide();
                 QCOMPARE(m_axis->isVisible(), false);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->show();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 QCOMPARE(m_axis->isVisible(), true);
             }
             void tst_QAbstractAxis::hide_data()
             {
             }
             void tst_QAbstractAxis::hide()
             {
                 m_axis->show();
                 QCOMPARE(m_axis->isVisible(),true);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 QSignalSpy spy9(m_axis, SIGNAL(minorGridVisibleChanged(bool)));
+                QSignalSpy spy10(m_axis, SIGNAL(gridLineColorChanged(QColor)));
+                QSignalSpy spy11(m_axis, SIGNAL(minorGridLineColorChanged(QColor)));
                 m_axis->hide();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 QCOMPARE(spy9.count(), 0);
+                QCOMPARE(spy10.count(), 0);
+                QCOMPARE(spy11.count(), 0);
                 QCOMPARE(m_axis->isVisible(),false);
             }

tests/auto/qabstractaxis/tst_qabstractaxis.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef TST_QABSTRACTAXIS_H
             #define TST_QABSTRACTAXIS_H
             #include <QtTest/QtTest>
             #include <tst_definitions.h>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QChartView>
             QT_CHARTS_USE_NAMESPACE
             class tst_QAbstractAxis : public QObject
             {
                 Q_OBJECT
             public slots:
                 virtual void initTestCase();
                 virtual void cleanupTestCase();
                 virtual void init(QAbstractAxis* axis,QAbstractSeries* series);
                 virtual void cleanup();
             private slots:
                 void axisPen_data();
                 void axisPen();
                 void axisPenColor_data();
                 void axisPenColor();
                 void gridLinePen_data();
                 void gridLinePen();
                 void minorGridLinePen_data();
                 void minorGridLinePen();
                 void lineVisible_data();
                 void lineVisible();
                 void gridLineVisible_data();
                 void gridLineVisible();
                 void minorGridLineVisible_data();
                 void minorGridLineVisible();
+                void gridLineColor_data();
+                void gridLineColor();
+                void minorGridLineColor_data();
+                void minorGridLineColor();
                 void visible_data();
                 void visible();
                 void labelsAngle_data();
                 void labelsAngle();
                 void labelsBrush_data();
                 void labelsBrush();
                 void labelsColor_data();
                 void labelsColor();
                 void labelsFont_data();
                 void labelsFont();
                 void labelsVisible_data();
                 void labelsVisible();
                 void orientation_data();
                 void orientation();
                 void setMax_data();
                 void setMax();
                 void setMin_data();
                 void setMin();
                 void setRange_data();
                 void setRange();
                 void shadesBorderColor_data();
                 void shadesBorderColor();
                 void shadesBrush_data();
                 void shadesBrush();
                 void shadesColor_data();
                 void shadesColor();
                 void shadesPen_data();
                 void shadesPen();
                 void shadesVisible_data();
                 void shadesVisible();
                 void show_data();
                 void show();
                 void hide_data();
                 void hide();
             protected:
                 void qabstractaxis();
             protected:
                 QChartView* m_view;
                 QChart* m_chart;
                 QAbstractAxis* m_axis;
                 QAbstractSeries* m_series;
             };
             #endif

tests/manual/polarcharttest/mainwindow.cpp +25 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "mainwindow.h"
             #include "chartview.h"
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QDateTimeAxis>
             #include <QtCharts/QCategoryAxis>
             #include <QtCharts/QPolarChart>
             #include <QtCore/QDebug>
             #include <QtCore/QtMath>
             #include <QtCore/QDateTime>
             QT_CHARTS_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_minorGridVisible(true),
                 m_minorArrowVisible(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_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_minorGridPen(new QPen(QBrush(QRgb(0x010101)), 1, Qt::DashLine)),
                 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)
             {
                 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->angularMinorTicksSpin, SIGNAL(valueChanged(int)),
                         this, SLOT(angularMinorTicksChanged(int)));
                 connect(ui->radialMinorTicksSpin, SIGNAL(valueChanged(int)),
                         this, SLOT(radialMinorTicksChanged(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->minorGridComboBox, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(minorGridIndexChanged(int)));
+                connect(ui->gridLineColorComboBox, SIGNAL(currentIndexChanged(int)),
+                        this, SLOT(gridLineColorIndexChanged(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->categoryLabelLocationCheckBox, SIGNAL(clicked()),
                         this, SLOT(categoryLabelLocationChecked()));
                 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->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->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_angularAxis->setMinorGridLinePen(*m_minorGridPen);
                 m_angularAxis->setMinorGridLineVisible(m_minorGridVisible);
                 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->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->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_radialAxis->setMinorGridLinePen(*m_minorGridPen);
                 m_radialAxis->setMinorGridLineVisible(m_minorGridVisible);
                 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::angularMinorTicksChanged(int value)
             {
                 // Minor tick valid only for QValueAxis
                 m_angularMinorTickCount = value;
                 if (m_angularAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_angularAxis)->setMinorTickCount(m_angularMinorTickCount);
             }
             void MainWindow::radialMinorTicksChanged(int value)
             {
                 // Minor tick valid only for QValueAxis
                 m_radialMinorTickCount = value;
                 if (m_radialAxisMode == AxisModeValue)
                     static_cast<QValueAxis *>(m_radialAxis)->setMinorTickCount(m_radialMinorTickCount);
             }
             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;
                 switch (index) {
                 case 0:
                     m_labelBrush = new QBrush(Qt::NoBrush);
                     m_labelsVisible = false;
                     break;
                 case 1:
                     m_labelBrush = new QBrush(Qt::black);
                     m_labelsVisible = true;
                     break;
                 case 2:
                     m_labelBrush = new QBrush(Qt::white);
                     m_labelsVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_radialAxis->setLabelsBrush(*m_labelBrush);
                 m_radialAxis->setLabelsVisible(m_labelsVisible);
                 m_angularAxis->setLabelsBrush(*m_labelBrush);
                 m_angularAxis->setLabelsVisible(m_labelsVisible);
             }
             void MainWindow::titleIndexChanged(int index)
             {
                 delete m_titleBrush;
                 switch (index) {
                 case 0:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     m_titleVisible = false;
                     m_angularTitle = QString();
                     m_radialTitle = QString();
                     break;
                 case 1:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     m_titleVisible = true;
                     m_angularTitle = QString();
                     m_radialTitle = QString();
                     break;
                 case 2:
                     m_titleBrush = new QBrush(Qt::NoBrush);
                     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_titleVisible = true;
                     m_angularTitle = QString("Angular Title");
                     m_radialTitle = QString("Radial Title");
                     break;
                 case 4:
                     m_titleBrush = new QBrush(Qt::white);
                     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->setTitleVisible(m_titleVisible);
                 m_radialAxis->setTitleText(m_radialTitle);
                 m_angularAxis->setTitleBrush(*m_titleBrush);
                 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::minorGridIndexChanged(int index)
             {
                 delete m_minorGridPen;
                 switch (index) {
                 case 0:
                     m_minorGridPen = new QPen(Qt::NoPen);
                     m_minorGridVisible = false;
                     break;
                 case 1:
                     m_minorGridPen = new QPen(Qt::black);
                     m_minorGridPen->setStyle(Qt::DashLine);
                     m_minorGridVisible = true;
                     break;
                 case 2:
                     m_minorGridPen = new QPen(Qt::green);
                     m_minorGridPen->setStyle(Qt::DotLine);
                     m_minorGridPen->setWidth(1);
                     m_minorGridVisible = true;
                     break;
                 default:
                     break;
                 }
                 m_angularAxis->setMinorGridLinePen(*m_minorGridPen);
                 m_angularAxis->setMinorGridLineVisible(m_minorGridVisible);
                 m_radialAxis->setMinorGridLinePen(*m_minorGridPen);
                 m_radialAxis->setMinorGridLineVisible(m_minorGridVisible);
             }
+            void MainWindow::gridLineColorIndexChanged(int index)
+            {
+                QColor color;
+                switch (index) {
+                case 0:
+                    color = Qt::black;
+                    break;
+                case 1:
+                    color = Qt::green;
+                    break;
+                case 2:
+                    color = Qt::red;
+                    break;
+                default:
+                    break;
+                }
+                m_angularAxis->setGridLineColor(color);
+                m_radialAxis->setGridLineColor(color);
+                m_angularAxis->setMinorGridLineColor(color);
+                m_radialAxis->setMinorGridLineColor(color);
+            }
             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(qreal(ui->angularMinSpin->value()), min))
                     ui->angularMinSpin->setValue(min);
                 if (!qFuzzyCompare(qreal(ui->angularMaxSpin->value()), max))
                     ui->angularMaxSpin->setValue(max);
             }
             void MainWindow::radialRangeChanged(qreal min, qreal max)
             {
                 if (!qFuzzyCompare(qreal(ui->radialMinSpin->value()), min))
                     ui->radialMinSpin->setValue(min);
                 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);
                     angularMinorTicksChanged(ui->angularMinorTicksSpin->value());
                     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);
                     radialMinorTicksChanged(ui->radialMinorTicksSpin->value());
                     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::categoryLabelLocationChecked()
             {
                 applyCategories();
             }
             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 (ui->categoryLabelLocationCheckBox->isChecked())
                         angCatAxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionOnValue);
                     else
                         angCatAxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionCenter);
                 }
                 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");
                     }
                     if (ui->categoryLabelLocationCheckBox->isChecked())
                         radCatAxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionOnValue);
                     else
                         radCatAxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionCenter);
                 }
             }

tests/manual/polarcharttest/mainwindow.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QtCharts/QPolarChart>
             #include <QtWidgets/QMainWindow>
             #include <QtGui/QFont>
             #include <QtCharts/QChart>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QAreaSeries>
             QT_BEGIN_NAMESPACE
             class QBrush;
             class QPen;
             namespace Ui {
             class MainWindow;
             }
             QT_END_NAMESPACE
             QT_CHARTS_USE_NAMESPACE
             class MainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 explicit MainWindow(QWidget *parent = 0);
                 ~MainWindow();
             public slots:
                 void angularTicksChanged(int value);
                 void radialTicksChanged(int value);
                 void angularMinorTicksChanged(int value);
                 void radialMinorTicksChanged(int value);
                 void anglesChanged(int value);
                 void angularMinChanged(double value);
                 void angularMaxChanged(double value);
                 void radialMinChanged(double value);
                 void radialMaxChanged(double value);
                 void angularShadesIndexChanged(int index);
                 void radialShadesIndexChanged(int index);
                 void labelFormatEdited(const QString &text);
                 void labelFontChanged(const QFont &font);
                 void labelFontSizeChanged(int value);
                 void animationIndexChanged(int index);
                 void labelsIndexChanged(int index);
                 void titleIndexChanged(int index);
                 void titleFontChanged(const QFont &font);
                 void titleFontSizeChanged(int value);
                 void gridIndexChanged(int index);
                 void minorGridIndexChanged(int index);
+                void gridLineColorIndexChanged(int index);
                 void arrowIndexChanged(int index);
                 void angularRangeChanged(qreal min, qreal max);
                 void radialRangeChanged(qreal min, qreal max);
                 void angularAxisIndexChanged(int index);
                 void radialAxisIndexChanged(int index);
                 void logBaseChanged(double value);
                 void niceNumbersChecked();
                 void dateFormatEdited(const QString &text);
                 void moreCategoriesChecked();
                 void categoryLabelLocationChecked();
                 void series1CheckBoxChecked();
                 void series2CheckBoxChecked();
                 void series3CheckBoxChecked();
                 void series4CheckBoxChecked();
                 void series5CheckBoxChecked();
                 void series6CheckBoxChecked();
                 void series7CheckBoxChecked();
                 void themeIndexChanged(int index);
                 void seriesHovered(QPointF point, bool state);
                 void seriesClicked(const QPointF &point);
                 void backgroundIndexChanged(int index);
                 void plotAreaIndexChanged(int index);
             private:
                 enum AxisMode {
                     AxisModeNone,
                     AxisModeValue,
                     AxisModeLogValue,
                     AxisModeDateTime,
                     AxisModeCategory
                 };
                 void initXYValueChart();
                 void setAngularAxis(AxisMode mode);
                 void setRadialAxis(AxisMode mode);
                 void applyRanges();
                 void applyCategories();
                 Ui::MainWindow *ui;
                 int m_angularTickCount;
                 int m_radialTickCount;
                 int m_angularMinorTickCount;
                 int m_radialMinorTickCount;
                 qreal m_labelsAngle;
                 qreal m_angularMin;
                 qreal m_angularMax;
                 qreal m_radialMin;
                 qreal m_radialMax;
                 bool m_angularShadesVisible;
                 bool m_radialShadesVisible;
                 bool m_labelsVisible;
                 bool m_titleVisible;
                 bool m_gridVisible;
                 bool m_arrowVisible;
                 bool m_minorGridVisible;
                 bool m_minorArrowVisible;
                 QBrush *m_angularShadesBrush;
                 QBrush *m_radialShadesBrush;
                 QBrush *m_labelBrush;
                 QBrush *m_titleBrush;
                 QBrush *m_backgroundBrush;
                 QBrush *m_plotAreaBackgroundBrush;
                 QPen *m_angularShadesPen;
                 QPen *m_radialShadesPen;
                 QPen *m_gridPen;
                 QPen *m_arrowPen;
                 QPen *m_minorGridPen;
                 QPen *m_backgroundPen;
                 QPen *m_plotAreaBackgroundPen;
                 QString m_labelFormat;
                 QFont m_currentLabelFont;
                 QFont m_currentTitleFont;
                 QChart::AnimationOptions m_animationOptions;
                 QString m_angularTitle;
                 QString m_radialTitle;
                 qreal m_base;
                 QString m_dateFormat;
                 QPolarChart *m_chart;
                 QAbstractAxis *m_angularAxis;
                 QAbstractAxis *m_radialAxis;
                 AxisMode m_angularAxisMode;
                 AxisMode m_radialAxisMode;
                 bool m_moreCategories;
                 QScatterSeries *m_series1;
                 QLineSeries *m_series2;
                 QLineSeries *m_series3;
                 QLineSeries *m_series4;
                 QAreaSeries *m_series5;
                 QSplineSeries *m_series6;
                 QScatterSeries *m_series7;
             };
             #endif // MAINWINDOW_H

tests/manual/polarcharttest/mainwindow.ui +39 -5

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>1193</width>
                 <height>1004</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>MainWindow</string>
               </property>
               <widget class="QWidget" name="centralWidget">
                <layout class="QHBoxLayout" name="horizontalLayout">
                 <item>
                  <widget class="ChartView" name="chartView"/>
                 </item>
                 <item>
                  <widget class="QGroupBox" name="settingsBox">
                   <property name="sizePolicy">
                    <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                     <horstretch>0</horstretch>
                     <verstretch>0</verstretch>
                    </sizepolicy>
                   </property>
                   <property name="minimumSize">
                    <size>
                     <width>200</width>
                     <height>0</height>
                    </size>
                   </property>
                   <property name="title">
                    <string>Settings</string>
                   </property>
                   <widget class="QComboBox" name="angularShadesComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>313</y>
                      <width>187</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No angular shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Gray angular shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Yellow ang. shades + custom pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="radialShadesComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>339</y>
                      <width>175</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No radial shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Green radial shades</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Blue rad. shades + custom pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="animationsComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>471</y>
                      <width>104</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <item>
                     <property name="text">
                      <string>No animations</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Series animation</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Grid animation</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>All animations</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="labelComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>445</y>
                      <width>134</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No labels</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black label</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>White label + blue pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="titleComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>551</y>
                      <width>130</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>3</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible empty title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Visible empty title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Invisible title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black title</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>White title + blue pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="gridComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>577</y>
                      <width>104</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Custom grid pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="arrowComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>603</y>
                      <width>114</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible arrow</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black arrow</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Custom arrow pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="angularAxisComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>23</y>
                      <width>134</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No Angular Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Value Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Log Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular DateTime Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Angular Category Axis</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="radialAxisComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>49</y>
                      <width>126</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>No Radial Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Value Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Log Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial DateTime Axis</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Radial Category Axis</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="themeComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
-                     <y>814</y>
+                     <y>810</y>
                      <width>131</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>0</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Theme: Light</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Cerulean</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Dark</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Brown Sand</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Ncs</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: High Contrast</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Blue Icy</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Theme: Qt</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QLabel" name="hoverLabel">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
-                     <y>840</y>
+                     <y>830</y>
                      <width>117</width>
                      <height>16</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Hover coordinates here!</string>
                    </property>
                   </widget>
                   <widget class="QComboBox" name="backgroundComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>877</y>
                      <width>195</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>0</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Background: White</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Background: Blue</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Background:  Yellow + Black Border</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QComboBox" name="plotAreaComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>903</y>
                      <width>165</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>0</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>PlotArea: Transparent</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>PlotArea: Magenta</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>PlotArea: Gray + Red Border</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>207</y>
                      <width>185</width>
                      <height>100</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout_2">
                     <item row="2" column="1">
                      <widget class="QDoubleSpinBox" name="radialMinSpin">
                       <property name="decimals">
                        <number>5</number>
                       </property>
                       <property name="minimum">
                        <double>-999999999.000000000000000</double>
                       </property>
                       <property name="maximum">
                        <double>999999999.000000000000000</double>
                       </property>
                       <property name="singleStep">
                        <double>10.000000000000000</double>
                       </property>
                      </widget>
                     </item>
                     <item row="3" column="0">
                      <widget class="QLabel" name="label_11">
                       <property name="text">
                        <string>Radial max</string>
                       </property>
                      </widget>
                     </item>
                     <item row="2" column="0">
                      <widget class="QLabel" name="label_12">
                       <property name="text">
                        <string>Radial min</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="0">
                      <widget class="QLabel" name="label_5">
                       <property name="text">
                        <string>Angular max</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="1">
                      <widget class="QDoubleSpinBox" name="angularMinSpin">
                       <property name="decimals">
                        <number>5</number>
                       </property>
                       <property name="minimum">
                        <double>-999999999.000000000000000</double>
                       </property>
                       <property name="maximum">
                        <double>999999999.000000000000000</double>
                       </property>
                       <property name="singleStep">
                        <double>10.000000000000000</double>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="0">
                      <widget class="QLabel" name="label_4">
                       <property name="text">
                        <string>Angular min</string>
                       </property>
                      </widget>
                     </item>
                     <item row="3" column="1">
                      <widget class="QDoubleSpinBox" name="radialMaxSpin">
                       <property name="decimals">
                        <number>5</number>
                       </property>
                       <property name="minimum">
                        <double>-999999999.000000000000000</double>
                       </property>
                       <property name="maximum">
                        <double>999999999.000000000000000</double>
                       </property>
                       <property name="singleStep">
                        <double>10.000000000000000</double>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="1">
                      <widget class="QDoubleSpinBox" name="angularMaxSpin">
                       <property name="decimals">
                        <number>5</number>
                       </property>
                       <property name="minimum">
                        <double>-999999999.000000000000000</double>
                       </property>
                       <property name="maximum">
                        <double>999999999.000000000000000</double>
                       </property>
                       <property name="singleStep">
                        <double>10.000000000000000</double>
                       </property>
                      </widget>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>365</y>
                      <width>210</width>
                      <height>74</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout_3">
                     <item row="0" column="0">
                      <widget class="QLabel" name="label_13">
                       <property name="text">
                        <string>Label format</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="1">
                      <widget class="QLineEdit" name="labelFormatEdit"/>
                     </item>
                     <item row="1" column="0">
                      <widget class="QLabel" name="label_14">
                       <property name="text">
                        <string>Label font size</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="1">
                      <widget class="QSpinBox" name="labelFontSizeSpin">
                       <property name="minimum">
                        <number>-100000</number>
                       </property>
                       <property name="maximum">
                        <number>100000</number>
                       </property>
                      </widget>
                     </item>
                     <item row="2" column="0" colspan="2">
                      <widget class="QFontComboBox" name="labelFontComboBox"/>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>497</y>
                      <width>190</width>
                      <height>48</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout_4">
                     <item row="0" column="0">
                      <widget class="QLabel" name="label_15">
                       <property name="text">
                        <string>Title font size</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="1">
                      <widget class="QSpinBox" name="titleFontSizeSpin">
                       <property name="minimum">
                        <number>-100000</number>
                       </property>
                       <property name="maximum">
                        <number>100000</number>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="0" colspan="2">
                      <widget class="QFontComboBox" name="titleFontComboBox"/>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>655</y>
                      <width>168</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <layout class="QHBoxLayout" name="horizontalLayout_2">
                     <item>
                      <widget class="QLabel" name="label_16">
                       <property name="text">
                        <string>Log Base</string>
                       </property>
                      </widget>
                     </item>
                     <item>
                      <widget class="QDoubleSpinBox" name="logBaseSpin">
                       <property name="decimals">
                        <number>5</number>
                       </property>
                       <property name="minimum">
                        <double>-999999999.000000000000000</double>
                       </property>
                       <property name="maximum">
                        <double>999999999.000000000000000</double>
                       </property>
                       <property name="value">
                        <double>8.000000000000000</double>
                       </property>
                      </widget>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>680</y>
-                     <width>191</width>
+                     <width>198</width>
                      <height>31</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout_6">
                     <item row="0" column="1">
                      <widget class="QCheckBox" name="moreCategoriesCheckBox">
                       <property name="text">
                        <string>More Categories</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="0">
                      <widget class="QCheckBox" name="niceNumbersCheckBox">
                       <property name="text">
                        <string>Nice Numbers</string>
                       </property>
                      </widget>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
-                     <y>740</y>
+                     <y>730</y>
                      <width>221</width>
                      <height>22</height>
                     </rect>
                    </property>
                    <layout class="QHBoxLayout" name="horizontalLayout_4">
                     <item>
                      <widget class="QLabel" name="label_17">
                       <property name="text">
                        <string>DateTime format</string>
                       </property>
                      </widget>
                     </item>
                     <item>
                      <widget class="QLineEdit" name="dateFormatEdit"/>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
-                     <y>766</y>
+                     <y>760</y>
                      <width>136</width>
                      <height>42</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout_5">
                     <item row="0" column="0">
                      <widget class="QCheckBox" name="series1checkBox">
                       <property name="text">
                        <string>1</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="1">
                      <widget class="QCheckBox" name="series2checkBox">
                       <property name="text">
                        <string>2</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="2">
                      <widget class="QCheckBox" name="series3checkBox">
                       <property name="text">
                        <string>3</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="3" rowspan="2">
                      <widget class="QCheckBox" name="series7checkBox">
                       <property name="text">
                        <string>7</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="0">
                      <widget class="QCheckBox" name="series4checkBox">
                       <property name="text">
                        <string>4</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="1">
                      <widget class="QCheckBox" name="series5checkBox">
                       <property name="text">
                        <string>5</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="2">
                      <widget class="QCheckBox" name="series6checkBox">
                       <property name="text">
                        <string>6</string>
                       </property>
                      </widget>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QWidget" name="layoutWidget">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>75</y>
                      <width>178</width>
                      <height>126</height>
                     </rect>
                    </property>
                    <layout class="QGridLayout" name="gridLayout">
                     <item row="1" column="0">
                      <widget class="QLabel" name="label_2">
                       <property name="text">
                        <string>Angular Tick count</string>
                       </property>
                      </widget>
                     </item>
                     <item row="2" column="1">
                      <widget class="QSpinBox" name="anglesSpin">
                       <property name="minimum">
                        <number>-9999</number>
                       </property>
                       <property name="maximum">
                        <number>9999</number>
                       </property>
                       <property name="singleStep">
                        <number>5</number>
                       </property>
                      </widget>
                     </item>
                     <item row="3" column="1">
                      <widget class="QSpinBox" name="radialMinorTicksSpin"/>
                     </item>
                     <item row="0" column="0">
                      <widget class="QLabel" name="label">
                       <property name="text">
                        <string>Radial Tick count</string>
                       </property>
                      </widget>
                     </item>
                     <item row="4" column="0">
                      <widget class="QLabel" name="label_7">
                       <property name="text">
                        <string>Angular Minor Tick count</string>
                       </property>
                      </widget>
                     </item>
                     <item row="0" column="1">
                      <widget class="QSpinBox" name="radialTicksSpin"/>
                     </item>
                     <item row="4" column="1">
                      <widget class="QSpinBox" name="angularMinorTicksSpin"/>
                     </item>
                     <item row="3" column="0">
                      <widget class="QLabel" name="label_6">
                       <property name="text">
                        <string>Radial Minor Tick count</string>
                       </property>
                      </widget>
                     </item>
                     <item row="1" column="1">
                      <widget class="QSpinBox" name="angularTicksSpin"/>
                     </item>
                     <item row="2" column="0">
                      <widget class="QLabel" name="label_3">
                       <property name="text">
                        <string>Label angles</string>
                       </property>
                      </widget>
                     </item>
                    </layout>
                   </widget>
                   <widget class="QComboBox" name="minorGridComboBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>630</y>
                      <width>141</width>
                      <height>20</height>
                     </rect>
                    </property>
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="currentIndex">
                     <number>1</number>
                    </property>
                    <item>
                     <property name="text">
                      <string>Invisible minor grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Black minor grid</string>
                     </property>
                    </item>
                    <item>
                     <property name="text">
                      <string>Custom minor grid pen</string>
                     </property>
                    </item>
                   </widget>
                   <widget class="QCheckBox" name="categoryLabelLocationCheckBox">
                    <property name="geometry">
                     <rect>
                      <x>10</x>
                      <y>710</y>
                      <width>142</width>
                      <height>17</height>
                     </rect>
                    </property>
                    <property name="text">
                     <string>Category Label On Tick</string>
                    </property>
                   </widget>
+                  <widget class="QComboBox" name="gridLineColorComboBox">
+                   <property name="geometry">
+                    <rect>
+                     <x>10</x>
+                     <y>850</y>
+                     <width>133</width>
+                     <height>20</height>
+                    </rect>
+                   </property>
+                   <property name="sizePolicy">
+                    <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+                     <horstretch>0</horstretch>
+                     <verstretch>0</verstretch>
+                    </sizepolicy>
+                   </property>
+                   <property name="currentIndex">
+                    <number>0</number>
+                   </property>
+                   <item>
+                    <property name="text">
+                     <string>Black grid line</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>Green grid line</string>
+                    </property>
+                   </item>
+                   <item>
+                    <property name="text">
+                     <string>Red grid line</string>
+                    </property>
+                   </item>
+                  </widget>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>1193</width>
                  <height>21</height>
                 </rect>
                </property>
               </widget>
               <widget class="QToolBar" name="mainToolBar">
                <attribute name="toolBarArea">
                 <enum>TopToolBarArea</enum>
                </attribute>
                <attribute name="toolBarBreak">
                 <bool>false</bool>
                </attribute>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>ChartView</class>
                <extends>QGraphicsView</extends>
                <header>chartview.h</header>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

tests/manual/qmlchartproperties/qml/qmlchartproperties/Chart.qml +10 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtCharts 2.1
             ChartView {
                 id: chartView
                 title: "Chart Title"
                 anchors.fill: parent
                 property variant chart: chartView
                 LineSeries {
                     name: "line"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     XYPoint { x: 1.9; y: 3.3 }
                     XYPoint { x: 2.1; y: 2.1 }
                     XYPoint { x: 2.9; y: 4.9 }
                     XYPoint { x: 3.4; y: 3.0 }
                     XYPoint { x: 4.1; y: 3.3 }
                     axisX: axisX
                     axisY: axisY
                 }
                 onVisibleChanged:                  console.log("chart.onVisibleChanged: " + visible);
                 onTitleColorChanged:               console.log("chart.onTitleColorChanged: " + color);
                 onBackgroundColorChanged:          console.log("chart.onBackgroundColorChanged: " + chart.backgroundColor);
                 onDropShadowEnabledChanged:        console.log("chart.onDropShadowEnabledChanged: " + enabled);
                 onBackgroundRoundnessChanged:      console.log("chart.onBackgroundRoundnessChanged: " + diameter);
                 onSeriesAdded:                     console.log("chart.onSeriesAdded: " + series.name);
                 onSeriesRemoved:                   console.log("chart.onSeriesRemoved: " + series.name);
                 onPlotAreaColorChanged:            console.log("chart.onPlotAreaColorChanged: " + chart.plotAreaColor);
                 onAnimationDurationChanged:        console.log("chart.onAnimationDurationChanged: "
                                                                + chart.animationDuration);
                 onAnimationEasingCurveChanged:     console.log("chart.onAnimationEasingCurveChanged: "
                                                                + chart.animationEasingCurve.type);
                 legend.onVisibleChanged:           console.log("legend.onVisibleChanged: " + chart.legend.visible);
                 legend.onBackgroundVisibleChanged: console.log("legend.onBackgroundVisibleChanged: " + visible);
                 legend.onColorChanged:             console.log("legend.onColorChanged: " + color);
                 legend.onBorderColorChanged:       console.log("legend.onBorderColorChanged: " + color);
                 legend.onLabelColorChanged:        console.log("legend.onLabelColorChanged: " + color);
                 legend.onReverseMarkersChanged:    console.log("legend.onReverseMarkersChanged: "
                                                                + chart.legend.reverseMarkers)
                 margins.onTopChanged:       console.log("chart.margins.onTopChanged: " + top );
                 margins.onBottomChanged:    console.log("chart.margins.onBottomChanged: " + bottom);
                 margins.onLeftChanged:      console.log("chart.margins.onLeftChanged: " + left);
                 margins.onRightChanged:     console.log("chart.margins.onRightChanged: " + right);
                 onPlotAreaChanged: {
                     console.log("chart.onPlotAreaChanged, width: " + chartView.plotArea.width
                                                                    + " height: " + chartView.plotArea.height
                                                                    + " y: " + chartView.plotArea.y
                                                                    + " x: " + chartView.plotArea.x);
                     marginVisualizer.opacity = 1.0;
                 }
                 ValueAxis{
                     id: axisX
+                    minorGridVisible: false
+                    minorTickCount: 2
                     onColorChanged:               console.log("axisX.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisX.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisX.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisX.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisX.onGridVisibleChanged: " + visible);
+                    onMinorGridVisibleChanged:    console.log("axisX.onMinorGridVisibleChanged: " + visible);
+                    onGridLineColorChanged:       console.log("axisX.onGridLineColorChanged: " + color);
+                    onMinorGridLineColorChanged:  console.log("axisX.onMinorGridLineColorChanged: " + color);
                     onShadesVisibleChanged:       console.log("axisX.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisX.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisX.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisX.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisX.onMaxChanged: " + max);
                     onReverseChanged:             console.log("axisX.onReverseChanged: " + reverse);
                 }
                 ValueAxis{
                     id: axisY
+                    minorGridVisible: false
+                    minorTickCount: 2
                     onColorChanged:               console.log("axisY.onColorChanged: " + color);
                     onLabelsVisibleChanged:       console.log("axisY.onLabelsVisibleChanged: " + visible);
                     onLabelsColorChanged:         console.log("axisY.onLabelsColorChanged: " + color);
                     onVisibleChanged:             console.log("axisY.onVisibleChanged: " + visible);
                     onGridVisibleChanged:         console.log("axisY.onGridVisibleChanged: " + visible);
+                    onMinorGridVisibleChanged:    console.log("axisX.onMinorGridVisibleChanged: " + visible);
+                    onGridLineColorChanged:       console.log("axisX.onGridLineColorChanged: " + color);
+                    onMinorGridLineColorChanged:  console.log("axisX.onMinorGridLineColorChanged: " + color);
                     onShadesVisibleChanged:       console.log("axisY.onShadesVisibleChanged: " + visible);
                     onShadesColorChanged:         console.log("axisY.onShadesColorChanged: " + color);
                     onShadesBorderColorChanged:   console.log("axisY.onShadesBorderColorChanged: " + color);
                     onMinChanged:                 console.log("axisY.onMinChanged: " + min);
                     onMaxChanged:                 console.log("axisY.onMaxChanged: " + max);
                     onReverseChanged:             console.log("axisY.onReverseChanged: " + reverse);
                 }
                 Rectangle {
                     id: marginVisualizer
                     color: "transparent"
                     border.color: "red"
                     anchors.fill: parent
                     anchors.topMargin: chartView.margins.top
                     anchors.bottomMargin: chartView.margins.bottom
                     anchors.leftMargin: chartView.margins.left
                     anchors.rightMargin: chartView.margins.right
                     opacity: 0.0
                     onOpacityChanged: if (opacity > 0.9) opacity = 0.0;
                     Behavior on opacity {
                         NumberAnimation { duration: 800 }
                     }
                 }
                 MouseArea {
                     id: zoomArea
                     anchors.fill: parent
                     acceptedButtons: Qt.LeftButton
                     property point mousePoint;
                     property point valuePoint;
                     onPressed: {
                         mousePoint.x = mouse.x
                         mousePoint.y = mouse.y
                         valuePoint = chart.mapToValue(mousePoint, series("line"));
                         // Mouse point and position should be the same!
                         console.log("mouse point: " + mouse.x + ", " + mouse.y);
                         console.log("value point: " + valuePoint);
                         console.log("position: " + chart.mapToPosition(valuePoint, series("line")));
                     }
                 }
             }

tests/manual/qmlchartproperties/qml/qmlchartproperties/ChartEditorAxis.qml +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             Row {
                 anchors.fill: parent
                 spacing: 5
                 property variant axis
                 Flow {
                     spacing: 5
                     flow: Flow.TopToBottom
                     height: parent.height
                     Button {
                         text: "axis visible"
                         onClicked: axis.visible = !axis.visible;
                     }
                     Button {
                         text: "axis line visible"
                         onClicked: axis.lineVisible = !axis.lineVisible;
                     }
                     Button {
                         text: "axis color"
                         onClicked: axis.color = main.nextColor();
                     }
                     Button {
                         text: "axis labels visible"
                         onClicked: axis.labelsVisible = !axis.labelsVisible;
                     }
                     Button {
                         text: "axis labels angle +"
                         onClicked: axis.labelsAngle += 5;
                     }
                     Button {
                         text: "axis labels angle -"
                         onClicked: axis.labelsAngle -= 5;
                     }
                     Button {
                         text: "axis labels color"
                         onClicked: axis.labelsColor = main.nextColor();
                     }
                     Button {
                         text: "axis grid visible"
                         onClicked: axis.gridVisible = !axis.gridVisible;
                     }
                     Button {
                         text: "axis minor grid visible"
                         onClicked: axis.minorGridVisible = !axis.minorGridVisible;
                     }
                     Button {
+                        text: "axis grid color"
+                        onClicked: axis.gridLineColor = main.nextColor();
+                    }
+                    Button {
+                        text: "axis minor grid color"
+                        onClicked: axis.minorGridLineColor = main.nextColor();
+                    }
+                    Button {
                         text: "axis shades visible"
                         onClicked: axis.shadesVisible = !axis.shadesVisible;
                     }
                     Button {
                         text: "axis shades color"
                         onClicked: axis.shadesColor = main.nextColor();
                     }
                     Button {
                         text: "axis shades bcolor"
                         onClicked: axis.shadesBorderColor = main.nextColor();
                     }
                     Button {
                         text: "axis title text"
                         onClicked: axis.titleText = axis.titleText + "X";
                     }
                     Button {
                         text: "axis title visible"
                         onClicked: axis.titleVisible = !axis.titleVisible;
                     }
                     Button {
                         text: "axis max +"
                         onClicked: axis.max += 0.1;
                     }
                     Button {
                         text: "axis max -"
                         onClicked: axis.max -= 0.1;
                     }
                     Button {
                         text: "axis min +"
                         onClicked: axis.min += 0.1;
                     }
                     Button {
                         text: "axis min -"
                         onClicked: axis.min -= 0.1;
                     }
                     Button {
                         text: "axis tick count +"
                         onClicked: axis.tickCount++;
                     }
                     Button {
                         text: "axis tick count -"
                         onClicked: axis.tickCount--;
                     }
                     Button {
                         text: "axis minor tick count +"
                         onClicked: axis.minorTickCount++;
                     }
                     Button {
                         text: "axis minor tick count -"
                         onClicked: axis.minorTickCount--;
                     }
                     Button {
                         text: "axis reverse"
                         onClicked: axis.reverse = !axis.reverse;
                     }
                     FontEditor {
                         id: fontEditor
                         fontDescription: "axis"
                         function editedFont() {
                             return axis.labelsFont;
                         }
                     }
                     FontEditor {
                         id: titleFontEditor
                         fontDescription: "title"
                         function editedFont() {
                             return axis.titleFont;
                         }
                     }
                 }
             }

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