HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2282:b5e4768d3a3a

BC fix: change gridLineVisibleChanged() back to gridVisibleChanged()

Jani Honkonen -

r2282:b5e4768d3a3a

parent child

Context file:

r2282:b5e4768d3a3a

Collapse all files

src/axis/chartaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "abstractdomain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsSimpleTextItem(item)),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 Q_ASSERT(item);
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setVisible(m_axis->isLineVisible());
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setVisible(m_axis->labelsVisible());
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_shades->setVisible(m_axis->shadesVisible());
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_grid->setVisible(m_axis->isGridLineVisible());
                 m_title->setZValue(ChartPresenter::GridZValue);
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents,true);
             }
             void ChartAxis::connectSlots()
             {
                 QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
-                QObject::connect(m_axis,SIGNAL(gridLineVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
+                QObject::connect(m_axis,SIGNAL(gridVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->childItems().size() == 0){
                     QGraphicsLineItem* arrow = new ArrowItem(this, this);
                     arrow->setPen(m_axis->linePen());
                     m_arrow->addToGroup(arrow);
                 }
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem* item = new QGraphicsLineItem(this);
                         item->setPen(m_axis->gridLinePen());
                         m_grid->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
                     arrow->setPen(m_axis->linePen());
                     QGraphicsLineItem* grid = new QGraphicsLineItem(this);
                     grid->setPen(m_axis->gridLinePen());
                     QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
                     label->setFont(m_axis->labelsFont());
                     label->setPen(m_axis->labelsPen());
                     label->setBrush(m_axis->labelsBrush());
                     m_arrow->addToGroup(arrow);
                     m_grid->addToGroup(grid);
                     m_labels->addToGroup(label);
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(m_axis->shadesPen());
                         shades->setBrush(m_axis->shadesBrush());
                         m_shades->addToGroup(shades);
                     }
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() ||  qFuzzyCompare(min(),max());
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             qreal ChartAxis::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxis::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QFont ChartAxis::font() const
             {
                 return m_axis->labelsFont();
             }
             QFont ChartAxis::titleFont() const
             {
                 return m_axis->titleFont();
             }
             QString ChartAxis::titleText() const
             {
                 return m_axis->titleText();
             }
             void ChartAxis::axisSelected()
             {
                 emit clicked();
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_axis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_axis->alignment();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             //handlers
             void ChartAxis::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxis::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxis::handleLabelsVisibleChanged(bool visible)
             {
                 m_labels->setVisible(visible);
             }
             void ChartAxis::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::handleLabelsPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                 static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleTitleTextChanged(const QString &title)
             {
                 Q_UNUSED(title)
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::handleTitleFontChanged(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
             }
             void ChartAxis::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());
                     }
                 }
             }
             //helpers
             QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1){
                     return labels;
                 }
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
             {
             //    Q_ASSERT(m_max > m_min);
                 //    Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = 0;
                 if (ticks > 1)
                     n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1) {
                     return labels;
                 }
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 There is only one x Axis visible at the time, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass AbstractAxis QAbstractAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis visible at the time, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the series object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
             */
             /*!
              *\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::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::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::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::title
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::title
               The title of the axis. Empty by default.
             */
             /*!
               \qmlproperty string AbstractAxis::title
               The title of the axis. Empty string by default.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Either Qt::AlignLeft or Qt::AlignBottom.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Either Qt.AlignLeft or Qt.AlignBottom.
             */
             /*!
               \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::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::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::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::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.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 return d_ptr->m_axisPen;
             }
             //TODO: remove me
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
-                    emit gridLineVisibleChanged(visible);
+                    emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit gridLinePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit labelsBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit labelsFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             //TODO: remove me
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::titleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a pen used to draw title.
             */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to title.
             */
             QPen QAbstractAxis::titlePen() const
             {
                 return d_ptr->m_titlePen;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush  QAbstractAxis::titleBrush() const
             {
                 return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit shadesPenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit shadesBrushChanged(brush);
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
             	QPen p = d_ptr->m_shadesPen;
             	if (p.color() != color) {
             		p.setColor(color);
             		setShadesPen(p);
             		emit shadesColorChanged(color);
             	}
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             // NOTE: should have const but it breaks BC:
             // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
             Qt::Orientation QAbstractAxis::orientation()
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_orientation(Qt::Orientation(0)),
                   m_alignment(0),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_gridLineVisible(true),
                   m_labelsVisible(true),
                   m_labelsAngle(0),
                   m_shadesVisible(false),
                   m_shadesBrush(Qt::SolidPattern),
                   m_shadesOpacity(1.0),
                   m_dirty(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (m_arrowVisible) {
                     if (forced || brush == m_labelsBrush){
                         q_ptr->setLabelsBrush(theme->labelBrush());
                     }
                     //TODO: introduce axis brush
                     if (forced || brush == m_titleBrush){
                         q_ptr->setTitleBrush(theme->labelBrush());
                     }
                     if (forced || pen == m_labelsPen){
                         q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
                     }
                     if (forced || pen == m_titlePen){
                         q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
                     }
                     if (forced || m_shadesVisible) {
                         if (forced || brush == m_shadesBrush){
                             q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                         }
                         if (forced || pen == m_shadesPen){
                             q_ptr->setShadesPen(theme->backgroundShadesPen());
                         }
                         if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                         	 q_ptr->setShadesVisible(true);
                         }
                     }
             		if (forced || pen == m_axisPen) {
             			q_ptr->setLinePen(theme->axisLinePen());
             		}
             		if (forced || pen == m_gridLinePen) {
             			q_ptr->setGridLinePen(theme->girdLinePen());
             		}
                     if (forced || font == m_labelsFont){
                     	q_ptr->setLabelsFont(theme->labelFont());
                     }
                     //TODO: discuss with Tero
                     if (forced || font == m_titleFont){
                         QFont font(m_labelsFont);
                         font.setBold(true);
                         q_ptr->setTitleFont(font);
                     }
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxis* axis = m_item.data();
                 Q_ASSERT(axis);
                 if(options.testFlag(QChart::GridAxisAnimations)) {
                     axis->setAnimation(new AxisAnimation(axis));
                 }else{
                     axis->setAnimation(0);
                 }
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             #include <QVariant>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QTCOMMERCIALCHART_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)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QPen lablesPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
                 Q_PROPERTY(QBrush lablesBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
                 //TODO: fix labels angles to work with layout
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
-                Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridLineVisibleChanged)
+                Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(QPen girdLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 //TODO: make wrapping of border for qml
                 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(QPen titlePen READ titlePen WRITE setTitlePen NOTIFY titlePenChanged)
                 Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ titleVisible WRITE setTitleVisible)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 //orientation
                 Q_PROPERTY(Qt::Orientation orinetation READ orientation)
                 //aligment
                 Q_PROPERTY(Qt::Alignment alignment READ alignment)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
                     AxisTypeCategory = 0x3,
                     AxisTypeDateTime = 0x4,
                     AxisTypeLogValue = 0x5
                 };
                 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;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 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 titleVisible() const;
                 void setTitleVisible(bool visible = true);
                 void setTitlePen(const QPen &pen);
                 QPen titlePen() const;
                 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(); //TODO: missing const <- BC
                 Qt::Alignment alignment() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void linePenChanged(const QPen& pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void labelsPenChanged(const QPen& pen);
                 void labelsBrushChanged(const QBrush& brush);
                 void labelsFontChanged(const QFont& pen);
                 void labelsAngleChanged(int angle);
                 void gridLinePenChanged(const QPen& pen);
-                void gridLineVisibleChanged(bool visible);
+                void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void titleTextChanged(const QString& title);
                 void titlePenChanged(const QPen& pen);
                 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);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis)
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

tests/auto/qabstractaxis/tst_qabstractaxis.cpp +16 -16

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tst_qabstractaxis.h"
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(Qt::Orientation)
             void tst_QAbstractAxis::initTestCase()
             {
             }
             void tst_QAbstractAxis::cleanupTestCase()
             {
             }
             void tst_QAbstractAxis::init(QAbstractAxis* axis, QAbstractSeries* series)
             {
                 m_axis = axis;
                 m_series = series;
                 m_view = new QChartView(new QChart());
                 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());
                 //TODO QCOMPARE(m_axis->axisPenColor(), QColor());
                 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());
                 //TODO QCOMPARE(m_axis->labelsColor(), QColor());
                 QCOMPARE(m_axis->labelsFont(), QFont());
                 QCOMPARE(m_axis->labelsPen(), QPen());
                 QCOMPARE(m_axis->labelsVisible(), true);
                 QCOMPARE(m_axis->orientation(), Qt::Orientation(0));
                 m_axis->setLineVisible(false);
                 m_axis->setLinePen(QPen());
                 m_axis->setLinePenColor(QColor());
                 m_axis->setGridLinePen(QPen());
                 m_axis->setGridLineVisible(false);
                 m_axis->setLabelsAngle(-1);
                 m_axis->setLabelsBrush(QBrush());
                 m_axis->setLabelsColor(QColor());
                 m_axis->setLabelsFont(QFont());
                 m_axis->setLabelsPen(QPen());
                 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);
                 //TODO QCOMPARE(m_axis->shadesBorderColor(), QColor());
                 //TODO QCOMPARE(m_axis->shadesBrush(), QBrush());
                 //TODO QCOMPARE(m_axis->shadesColor(), QColor());
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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", SkipAll);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->gridLinePen(), gridLinePen);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isGridLineVisible(), gridLineVisible);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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", SkipAll);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsFont(), labelsFont);
             }
             void tst_QAbstractAxis::labelsPen_data()
             {
                 QTest::addColumn<QPen>("labelsPen");
                 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::labelsPen()
             {
                 QFETCH(QPen, labelsPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
+                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)));
                 m_axis->setLabelsPen(labelsPen);
                 QCOMPARE(m_axis->labelsPen(), labelsPen);
                 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);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->labelsPen(), labelsPen);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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(), 1);
                 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", SkipAll);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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", SkipAll);
             }
             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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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);
                 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(gridLineVisibleChanged(bool)));
+                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)));
                 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(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(gridLineVisibleChanged(bool)));
+                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)));
                 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(m_axis->isVisible(),false);
             }

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