HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2781:7c9f8e5a27d8

Add possibility to set reverse values to axes...

Titta Heikkala -

r2781:7c9f8e5a27d8

parent child

Context file:

r2781:7c9f8e5a27d8

Expand all files

src/charts/areachart/areachartitem.cpp +27 -5

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/areachartitem_p.h>
             #include <QtCharts/QAreaSeries>
             #include <private/qareaseries_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item)
                 : ChartItem(areaSeries->d_func(),item),
                   m_series(areaSeries),
                   m_upper(0),
                   m_lower(0),
                   m_pointsVisible(false),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(areaSeries->pointLabelsFormat()),
                   m_pointLabelsFont(areaSeries->pointLabelsFont()),
                   m_pointLabelsColor(areaSeries->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable, true);
                 setZValue(ChartPresenter::LineChartZValue);
                 if (m_series->upperSeries())
                     m_upper = new AreaBoundItem(this, m_series->upperSeries());
                 if (m_series->lowerSeries())
                     m_lower = new AreaBoundItem(this, m_series->lowerSeries());
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), areaSeries, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), areaSeries, SIGNAL(hovered(QPointF,bool)));
                 QObject::connect(this, SIGNAL(pressed(QPointF)), areaSeries, SIGNAL(pressed(QPointF)));
                 QObject::connect(this, SIGNAL(released(QPointF)), areaSeries, SIGNAL(released(QPointF)));
                 QObject::connect(this, SIGNAL(doubleClicked(QPointF)),
                                  areaSeries, SIGNAL(doubleClicked(QPointF)));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsFontChanged(QFont)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(areaSeries, SIGNAL(pointLabelsColorChanged(QColor)),
                                  this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             void AreaChartItem::setPresenter(ChartPresenter *presenter)
             {
                 if (m_upper)
                     m_upper->setPresenter(presenter);
                 if (m_lower) {
                     m_lower->setPresenter(presenter);
                 }
             	ChartItem::setPresenter(presenter);
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 QRectF rect(QPointF(0,0),domain()->size());
                 path = m_upper->path();
                 if (m_lower) {
                     // Note: Polarcharts always draw area correctly only when both series have equal width or are
                     // fully displayed. If one series is partally off-chart, the connecting line between
                     // the series does not attach to the end of the partially hidden series but to the point
                     // where it intersects the axis line. The problem is especially noticeable when one of the series
                     // is entirely off-chart, in which case the connecting line connects two ends of the
                     // visible series.
                     // This happens because we get the paths from linechart, which omits off-chart segments.
                     // To properly fix, linechart would need to provide true full path, in right, left, and the rest
                     // portions to enable proper clipping. However, combining those to single visually unified area
                     // would be a nightmare, since they would have to be painted separately.
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     if (presenter()->chartType() == QChart::ChartTypeCartesian) {
                         path.lineTo(last.x(), rect.bottom());
                         path.lineTo(first.x(), rect.bottom());
                     } else { // polar
                         path.lineTo(rect.center());
                     }
                 }
                 path.closeSubpath();
                 // Only zoom in if the bounding rect of the path fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (path.boundingRect().height() <= INT_MAX
                         && path.boundingRect().width() <= INT_MAX) {
                     prepareGeometryChange();
                     m_path = path;
                     m_rect = path.boundingRect();
                     update();
                 }
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 if (m_upper) {
                     AbstractDomain* d = m_upper->domain();
                     d->setSize(domain()->size());
                     d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                     m_upper->handleDomainUpdated();
                 }
                 if (m_lower) {
                     AbstractDomain* d = m_lower->domain();
                     d->setSize(domain()->size());
                     d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                     m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 if (presenter()->chartType() == QChart::ChartTypePolar)
                     painter->setClipRegion(QRegion(clipRect.toRect(), QRegion::Ellipse));
                 else
                     painter->setClipRect(clipRect);
+                reversePainter(painter, clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(m_upper->geometryPoints());
                     if (m_lower)
                         painter->drawPoints(m_lower->geometryPoints());
                 }
+                reversePainter(painter, clipRect);
                 // Draw series point label
                 if (m_pointLabelsVisible) {
                     static const QString xPointTag(QLatin1String("@xPoint"));
                     static const QString yPointTag(QLatin1String("@yPoint"));
                     const int labelOffset = 2;
                     painter->setFont(m_pointLabelsFont);
                     painter->setPen(QPen(m_pointLabelsColor));
                     QFontMetrics fm(painter->font());
                     QString pointLabel;
                     if (m_series->upperSeries()) {
                         for (int i(0); i < m_series->upperSeries()->count(); i++) {
                             pointLabel = m_pointLabelsFormat;
                             pointLabel.replace(xPointTag,
                                                presenter()->numberToString(m_series->upperSeries()->at(i).x()));
                             pointLabel.replace(yPointTag,
                                                presenter()->numberToString(m_series->upperSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_upper->geometryPoints().at(i));
-                            position.setX(position.x() - pointLabelWidth / 2);
+                            if (!seriesPrivate()->reverseXAxis())
-                            position.setY(position.y() - m_series->upperSeries()->pen().width() / 2 - labelOffset);
+                                position.setX(position.x() - pointLabelWidth / 2);
+                            else
+                                position.setX(domain()->size().width() - position.x() - pointLabelWidth / 2);
+                            if (!seriesPrivate()->reverseYAxis()) {
+                                position.setY(position.y() - m_series->upperSeries()->pen().width() / 2
+                                              - labelOffset);
+                            } else {
+                                position.setY(domain()->size().height() - position.y()
+                                              - m_series->upperSeries()->pen().width() / 2 - labelOffset);
+                            }
                             painter->drawText(position, pointLabel);
                         }
                     }
                     if (m_series->lowerSeries()) {
                         for (int i(0); i < m_series->lowerSeries()->count(); i++) {
                             pointLabel = m_pointLabelsFormat;
                             pointLabel.replace(xPointTag,
                                                presenter()->numberToString(m_series->lowerSeries()->at(i).x()));
                             pointLabel.replace(yPointTag,
                                                presenter()->numberToString(m_series->lowerSeries()->at(i).y()));
                             // Position text in relation to the point
                             int pointLabelWidth = fm.width(pointLabel);
                             QPointF position(m_lower->geometryPoints().at(i));
-                            position.setX(position.x() - pointLabelWidth / 2);
+                            if (!seriesPrivate()->reverseXAxis())
-                            position.setY(position.y() - m_series->lowerSeries()->pen().width() / 2 - labelOffset);
+                                position.setX(position.x() - pointLabelWidth / 2);
+                            else
+                                position.setX(domain()->size().width() - position.x() - pointLabelWidth / 2);
+                            if (!seriesPrivate()->reverseYAxis()) {
+                                position.setY(position.y() - m_series->lowerSeries()->pen().width() / 2
+                                              - labelOffset);
+                            } else {
+                                position.setY(domain()->size().height() - position.y()
+                                              - m_series->lowerSeries()->pen().width() / 2 - labelOffset);
+                            }
                             painter->drawText(position, pointLabel);
                         }
                     }
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit pressed(m_upper->domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 ChartItem::mousePressEvent(event);
             }
             void AreaChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit released(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
                 if (m_mousePressed)
                     emit clicked(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 ChartItem::mouseReleaseEvent(event);
             }
             void AreaChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit doubleClicked(m_upper->domain()->calculateDomainPoint(m_lastMousePos));
                 ChartItem::mouseDoubleClickEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

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

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

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

src/charts/axis/horizontalaxis.cpp +76 -16

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/horizontalaxis_p.h>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty() && axis()->type() != QAbstractAxis::AxisTypeLogValue)
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
                 QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(arrow.at(0));
                 if (axis()->alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
                 else if (axis()->alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
                 const QLatin1String ellipsis("...");
                 //title
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 qreal availableSpace = axisRect.height() - labelPadding();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     availableSpace -= titlePadding() * 2.0;
                     qreal minimumLabelHeight = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                 QStringLiteral("...")).height();
                     qreal titleSpace = availableSpace - minimumLabelHeight;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  gridRect.width(), titleSpace,
                                                                  titleBoundingRect));
                     title->setTextWidth(titleBoundingRect.width());
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignTop)
                         title->setPos(center.x(), axisRect.top() + titlePadding());
                     else  if (axis()->alignment() == Qt::AlignBottom)
                         title->setPos(center.x(), axisRect.bottom() - titleBoundingRect.height() - titlePadding());
                     availableSpace -= titleBoundingRect.height();
                 }
                 if (layout.isEmpty() && axis()->type() == QAbstractAxis::AxisTypeLogValue)
                     return;
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(arrow.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
-                    gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
+                    if (axis()->isReverse()) {
+                        gridItem->setLine(gridRect.right() - layout[i] + gridRect.left(), gridRect.top(),
+                                gridRect.right() - layout[i] + gridRect.left(), gridRect.bottom());
+                    } else {
+                        gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
+                    }
                     //label text wrapping
-                    QString text = labelList.at(i);
+                    QString text;
+                    if (axis()->isReverse() && axis()->type() != QAbstractAxis::AxisTypeCategory)
+                        text = labelList.at(labelList.count() - i - 1);
+                    else
+                        text = labelList.at(i);
                     QRectF boundingRect;
                     // don't truncate empty labels
                     if (text.isEmpty()) {
                         labelItem->setHtml(text);
                     } else  {
                         qreal labelWidth = axisRect.width() / layout.count() - (2 * labelPadding());
                         QString truncatedText = ChartPresenter::truncatedText(axis()->labelsFont(), text,
                                                                               axis()->labelsAngle(),
                                                                               labelWidth,
                                                                               availableSpace, boundingRect);
                         labelItem->setTextWidth(ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                  truncatedText).width());
                         labelItem->setHtml(truncatedText);
                     }
                     //label transformation origin point
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     qreal heightDiff = rect.height() - boundingRect.height();
                     qreal widthDiff = rect.width() - boundingRect.width();
                     //ticks and label position
                     if (axis()->alignment() == Qt::AlignTop) {
-                        labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() + (heightDiff / 2.0) - labelPadding());
+                        if (axis()->isReverse()) {
-                        tickItem->setLine(layout[i], axisRect.bottom(), layout[i], axisRect.bottom() - labelPadding());
+                            labelItem->setPos(gridRect.right() - layout[layout.size() - i - 1]
+                                    + gridRect.left() - center.x(),
+                                    axisRect.bottom() - rect.height()
+                                    + (heightDiff / 2.0) - labelPadding());
+                            tickItem->setLine(gridRect.right() + gridRect.left() - layout[i],
+                                              axisRect.bottom(),
+                                              gridRect.right() + gridRect.left() - layout[i],
+                                              axisRect.bottom() - labelPadding());
+                        } else {
+                            labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height()
+                                              + (heightDiff / 2.0) - labelPadding());
+                            tickItem->setLine(layout[i], axisRect.bottom(),
+                                              layout[i], axisRect.bottom() - labelPadding());
+                        }
                     } else if (axis()->alignment() == Qt::AlignBottom) {
-                        labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2.0) + labelPadding());
+                        if (axis()->isReverse()) {
-                        tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
+                            labelItem->setPos(gridRect.right() - layout[layout.size() - i - 1]
+                                    + gridRect.left() - center.x(),
+                                    axisRect.top() - (heightDiff / 2.0) + labelPadding());
+                            tickItem->setLine(gridRect.right() + gridRect.left() - layout[i], axisRect.top(),
+                                              gridRect.right() + gridRect.left() - layout[i],
+                                              axisRect.top() + labelPadding());
+                        } else {
+                            labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2.0)
+                                              + labelPadding());
+                            tickItem->setLine(layout[i], axisRect.top(),
+                                              layout[i], axisRect.top() + labelPadding());
+                        }
                     }
                     //label in between
                     bool forceHide = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
-                        qreal leftBound = qMax(layout[i], gridRect.left());
+                        qreal leftBound;
-                        qreal rightBound = qMin(layout[i + 1], gridRect.right());
+                        qreal rightBound;
+                        if (axis()->isReverse()) {
+                            leftBound = qMax(gridRect.right() + gridRect.left() - layout[i + 1],
+                                    gridRect.left());
+                            rightBound = qMin(gridRect.right() + gridRect.left() - layout[i], gridRect.right());
+                        } else {
+                            leftBound = qMax(layout[i], gridRect.left());
+                            rightBound = qMin(layout[i + 1], gridRect.right());
+                        }
                         const qreal delta = rightBound - leftBound;
                         if (axis()->type() != QAbstractAxis::AxisTypeCategory) {
                             // Hide label in case visible part of the category at the grid edge is too narrow
                             if (delta < boundingRect.width()
                                 && (leftBound == gridRect.left() || rightBound == gridRect.right())) {
                                 forceHide = true;
                             } else {
                                 labelItem->setPos(leftBound + (delta / 2.0) - center.x(), labelItem->pos().y());
                             }
                         } else {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionCenter) {
                                 if (delta < boundingRect.width()
                                     && (leftBound == gridRect.left() || rightBound == gridRect.right())) {
                                     forceHide = true;
                                 } else {
                                     labelItem->setPos(leftBound + (delta / 2.0) - center.x(),
                                                       labelItem->pos().y());
                                 }
                             } else if (categoryAxis->labelsPosition()
                                        == QCategoryAxis::AxisLabelsPositionOnValue) {
-                                labelItem->setPos(rightBound - center.x(), labelItem->pos().y());
+                                if (axis()->isReverse())
+                                    labelItem->setPos(leftBound - center.x(), labelItem->pos().y());
+                                else
+                                    labelItem->setPos(rightBound - center.x(), labelItem->pos().y());
                             }
                         }
                     }
                     //label overlap detection - compensate one pixel for rounding errors
                     if ((labelItem->pos().x() < width && labelItem->toPlainText() == ellipsis) || forceHide ||
                         (labelItem->pos().x() + (widthDiff / 2.0)) < (axisRect.left() - 1.0) ||
                         (labelItem->pos().x() + (widthDiff / 2.0) - 1.0) > axisRect.right()) {
                         labelItem->setVisible(false);
                     } else {
                         labelItem->setVisible(true);
                         width = boundingRect.width() + labelItem->pos().x();
                     }
                     //shades
                     QGraphicsRectItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at((i / 2) + 1));
                     if (shadeItem) {
                         qreal leftBound;
                         qreal rightBound;
                         if (i == 0) {
-                            leftBound = gridRect.left();
+                            if (axis()->isReverse()) {
-                            rightBound = layout[0];
+                                leftBound = gridRect.right() + gridRect.left() - layout[i];
-                        } else {
-                            leftBound = layout[i];
-                            if (i == layout.size() - 1)
                                 rightBound = gridRect.right();
-                            else
+                            } else {
-                                rightBound = qMin(layout[i + 1], gridRect.right());
+                                leftBound = gridRect.left();
+                                rightBound = layout[0];
+                            }
+                        } else {
+                            if (axis()->isReverse()) {
+                                rightBound = gridRect.right() + gridRect.left() - layout[i];
+                                if (i == layout.size() - 1) {
+                                    leftBound = gridRect.left();
+                                } else {
+                                    leftBound = qMax(gridRect.right() + gridRect.left() - layout[i + 1],
+                                            gridRect.left());
+                                }
+                            } else {
+                                leftBound = layout[i];
+                                if (i == layout.size() - 1)
+                                    rightBound = gridRect.right();
+                                else
+                                    rightBound = qMin(layout[i + 1], gridRect.right());
+                            }
                         }
                         if (leftBound < gridRect.left())
                             leftBound = gridRect.left();
                         if (rightBound > gridRect.right())
                             rightBound = gridRect.right();
                         shadeItem->setRect(leftBound, gridRect.top(), rightBound - leftBound,
                                            gridRect.height());
                         if (shadeItem->rect().width() <= 0.0)
                             shadeItem->setVisible(false);
                         else
                             shadeItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal x = gridItem->line().p1().x();
                     if (x < gridRect.left() || x > gridRect.right()) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     } else {
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.right(), gridRect.top(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.left(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF HorizontalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0,0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(),
                                                                         QStringLiteral("..."));
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2.0));
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2.0));
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QT_CHARTS_END_NAMESPACE

src/charts/axis/qabstractaxis.cpp +32 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \inmodule Qt Charts
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                 that would result in different domains is not supported, such as specifying
                 QValueAxis and QLogValueAxis on the same orientation.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \qmltype AbstractAxis
                 \instantiates QAbstractAxis
                 \inqmlmodule QtCharts
                 \brief The AbstractAxis is a base element used for specialized axis elements.
                 Each series can be bound to only one horizontal and vertical axis.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the axis object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
                 \value AxisTypeLogValue
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::linePen
               The pen of the line.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels. Only the color of the brush is relevant.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::gridLinePen
               The pen of the grid line.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the Qt documentation for more details of Font.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesPen
               The pen of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::shadesBrush
               The brush of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \qmlproperty bool AbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \property QAbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text. Only the color of the brush is relevant.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
             */
             /*!
               \qmlproperty Qt.Orientation AbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
+              \property QAbstractAxis::reverse
+              The reverse property defines if reverse axis is used. By default the value is false.
+              Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
+              All axes of the same orientation attached to same series must be reversed if one is reversed or
+              the behavior is undefined.
+            */
+            /*!
+              \qmlproperty alignment AbstractAxis::reverse
+              The reverse property defines if reverse axis is used. By default the value is false.
+              Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
+              All axes of the same orientation attached to same series must be reversed if one is reversed or
+              the behavior is undefined.
+            */
+            /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::linePenChanged(const QPen& pen)
               The pen of the line of the axis has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsFontChanged(const QFont& font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
               The brush of the axis labels has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::labelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridLinePenChanged(const QPen& pen)
               The pen of the grid line has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::titleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::titleTextChanged(const QString& text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleTextChanged(String text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
               The brush of the axis title has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::titleFontChanged(const QFont& font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
               The brush of the axis shades has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_axisPen;
             }
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return linePen().color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit gridLinePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit labelsBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit labelsFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return labelsBrush().color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit titleVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isTitleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush QAbstractAxis::titleBrush() const
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit shadesPenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit shadesBrushChanged(brush);
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return shadesBrush().color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setShadesPen(p);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return shadesPen().color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             Qt::Orientation QAbstractAxis::orientation() const
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
+            bool QAbstractAxis::isReverse() const
+            {
+                return d_ptr->m_reverse;
+            }
+            void QAbstractAxis::setReverse(bool reverse)
+            {
+                if (d_ptr->m_reverse != reverse && type() != QAbstractAxis::AxisTypeBarCategory) {
+                    d_ptr->m_reverse = reverse;
+                    emit reverseChanged(reverse);
+                }
+            }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_alignment(0),
                   m_orientation(Qt::Orientation(0)),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_axisPen(QChartPrivate::defaultPen()),
                   m_axisBrush(QChartPrivate::defaultBrush()),
                   m_gridLineVisible(true),
                   m_gridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   m_shadesOpacity(1.0),
-                  m_dirty(false)
+                  m_dirty(false),
+                  m_reverse(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->girdLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
                     q_ptr->setLabelsFont(theme->labelFont());
                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
                     q_ptr->setTitleBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
                     QFont font(m_labelsFont);
                     font.setBold(true);
                     q_ptr->setTitleFont(font);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                      q_ptr->setShadesVisible(true);
                 } else if (forced) {
                     q_ptr->setShadesVisible(false);
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (axis->animation())
                     axis->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::GridAxisAnimations))
                     axis->setAnimation(new AxisAnimation(axis));
                 else
                     axis->setAnimation(0);
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

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

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

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTAXIS_P_H
             #define QABSTRACTAXIS_P_H
             #include <QtCharts/QAbstractAxis>
             #include <private/chartaxiselement_p.h>
             #include <QtCharts/QChart>
             #include <QtCore/QDebug>
             QT_BEGIN_NAMESPACE
             class QGraphicsItem;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class AbstractDomain;
             class QChart;
             class QAbstractSeries;
             class ChartTheme;
             class ChartElement;
             class QT_CHARTS_AUTOTEST_EXPORT QAbstractAxisPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractAxisPrivate(QAbstractAxis *q);
                 ~QAbstractAxisPrivate();
             public:
                 Qt::Alignment alignment() const { return m_alignment; }
                 Qt::Orientation orientation() const { return m_orientation; }
                 void setAlignment( Qt::Alignment alignment);
                 virtual void initializeDomain(AbstractDomain *domain) = 0;
                 virtual void initializeGraphics(QGraphicsItem *parent) = 0;
                 virtual void initializeTheme(ChartTheme* theme, bool forced = false);
                 virtual void initializeAnimations(QChart::AnimationOptions options);
                 //interface for manipulating range form base class
                 virtual void setMin(const QVariant &min) = 0;
                 virtual void setMax(const QVariant &max) = 0;
                 virtual void setRange(const QVariant &min, const QVariant &max) = 0;
                 //interface manipulating range form domain
                 virtual void setRange(qreal min, qreal max) = 0;
                 virtual qreal min() = 0;
                 virtual qreal max() = 0;
                 ChartAxisElement *axisItem() { return m_item.data(); }
             public Q_SLOTS:
                 void handleRangeChanged(qreal min, qreal max);
             Q_SIGNALS:
                 void rangeChanged(qreal min, qreal max);
             protected:
                 QAbstractAxis *q_ptr;
                 QChart *m_chart;
                 QScopedPointer<ChartAxisElement> m_item;
             private:
                 QList<QAbstractSeries*> m_series;
                 Qt::Alignment m_alignment;
                 Qt::Orientation m_orientation;
                 bool m_visible;
                 bool m_arrowVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_titleVisible;
                 QBrush m_titleBrush;
                 QFont m_titleFont;
                 QString m_title;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 bool m_dirty;
+                bool m_reverse;
                 friend class QAbstractAxis;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/charts/axis/verticalaxis.cpp +85 -17

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/verticalaxis_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty() && axis()->type() != QAbstractAxis::AxisTypeLogValue)
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
                 QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(arrow.at(0));
                 //arrow position
                 if (axis()->alignment() == Qt::AlignLeft)
                     arrowItem->setLine(axisRect.right(), gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if (axis()->alignment() == Qt::AlignRight)
                     arrowItem->setLine(axisRect.left(), gridRect.top(), axisRect.left(), gridRect.bottom());
                 //title
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 qreal availableSpace = axisRect.width() - labelPadding();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     availableSpace -= titlePadding() * 2.0;
                     qreal minimumLabelWidth = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                QStringLiteral("...")).width();
                     qreal titleSpace = availableSpace - minimumLabelWidth;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(90.0),
                                                                  titleSpace, gridRect.height(),
                                                                  titleBoundingRect));
                     title->setTextWidth(titleBoundingRect.height());
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignLeft)
                         title->setPos(axisRect.left() - titleBoundingRect.width() / 2.0 + titleBoundingRect.height() / 2.0 + titlePadding(), center.y());
                     else if (axis()->alignment() == Qt::AlignRight)
                         title->setPos(axisRect.right() - titleBoundingRect.width() / 2.0 - titleBoundingRect.height() / 2.0 - titlePadding(), center.y());
                     title->setTransformOriginPoint(titleBoundingRect.center());
                     title->setRotation(270);
                     availableSpace -= titleBoundingRect.height();
                 }
                 if (layout.isEmpty() && axis()->type() == QAbstractAxis::AxisTypeLogValue)
                     return;
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrow.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
-                    gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
+                    if (axis()->isReverse()) {
+                        gridItem->setLine(gridRect.left(), gridRect.top() + gridRect.bottom() - layout[i],
+                                          gridRect.right(), gridRect.top() + gridRect.bottom() - layout[i]);
+                    } else {
+                        gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
+                    }
                     //label text wrapping
-                    QString text = labelList.at(i);
+                    QString text;
+                    if (axis()->isReverse() && axis()->type() != QAbstractAxis::AxisTypeCategory)
+                        text = labelList.at(labelList.count() - i - 1);
+                    else
+                        text = labelList.at(i);
                     QRectF boundingRect;
                     // don't truncate empty labels
                     if (text.isEmpty()) {
                         labelItem->setHtml(text);
                     } else {
                         qreal labelHeight = (axisRect.height() / layout.count()) - (2 * labelPadding());
                         QString truncatedText = ChartPresenter::truncatedText(axis()->labelsFont(), text,
                                                                               axis()->labelsAngle(),
                                                                               availableSpace,
                                                                               labelHeight, boundingRect);
                         labelItem->setTextWidth(ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                  truncatedText).width());
                         labelItem->setHtml(truncatedText);
                     }
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     qreal widthDiff = rect.width() - boundingRect.width();
                     qreal heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
                     if (axis()->alignment() == Qt::AlignLeft) {
-                        labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0) - labelPadding(), layout[i] - center.y());
+                        if (axis()->isReverse()) {
-                        tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
+                            labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0)
+                                              - labelPadding(),
+                                              gridRect.top() + gridRect.bottom()
+                                              - layout[layout.size() - i - 1] - center.y());
+                            tickItem->setLine(axisRect.right() - labelPadding(),
+                                              gridRect.top() + gridRect.bottom() - layout[i],
+                                              axisRect.right(),
+                                              gridRect.top() + gridRect.bottom() - layout[i]);
+                        } else {
+                            labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0)
+                                              - labelPadding(),
+                                              layout[i] - center.y());
+                            tickItem->setLine(axisRect.right() - labelPadding(), layout[i],
+                                              axisRect.right(), layout[i]);
+                        }
                     } else if (axis()->alignment() == Qt::AlignRight) {
-                        labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0), layout[i] - center.y());
+                        if (axis()->isReverse()) {
-                        tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
+                            tickItem->setLine(axisRect.left(),
+                                              gridRect.top() + gridRect.bottom() - layout[i],
+                                              axisRect.left() + labelPadding(),
+                                              gridRect.top() + gridRect.bottom() - layout[i]);
+                            labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0),
+                                              gridRect.top() + gridRect.bottom()
+                                              - layout[layout.size() - i - 1] - center.y());
+                        } else {
+                            labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0),
+                                              layout[i] - center.y());
+                            tickItem->setLine(axisRect.left(), layout[i],
+                                              axisRect.left() + labelPadding(), layout[i]);
+                        }
                     }
                     //label in between
                     bool forceHide = false;
                     bool labelOnValue = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
-                        qreal lowerBound = qMin(layout[i], gridRect.bottom());
+                        qreal lowerBound;
-                        qreal upperBound = qMax(layout[i + 1], gridRect.top());
+                        qreal upperBound;
+                        if (axis()->isReverse()) {
+                            lowerBound = qMax(gridRect.top() + gridRect.bottom() - layout[i + 1],
+                                    gridRect.top());
+                            upperBound = qMin(gridRect.top() + gridRect.bottom() - layout[i],
+                                              gridRect.bottom());
+                        } else {
+                            lowerBound = qMin(layout[i], gridRect.bottom());
+                            upperBound = qMax(layout[i + 1], gridRect.top());
+                        }
                         const qreal delta = lowerBound - upperBound;
                         if (axis()->type() != QAbstractAxis::AxisTypeCategory) {
                             // Hide label in case visible part of the category at the grid edge is too narrow
                             if (delta < boundingRect.height()
                                 && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                                 forceHide = true;
                             } else {
                                 labelItem->setPos(labelItem->pos().x(),
                                                   lowerBound - (delta / 2.0) - center.y());
                             }
                         } else {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionCenter) {
                                 if (delta < boundingRect.height()
                                     && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                                     forceHide = true;
                                 } else {
                                     labelItem->setPos(labelItem->pos().x(),
                                                       lowerBound - (delta / 2.0) - center.y());
                                 }
                             } else if (categoryAxis->labelsPosition()
                                        == QCategoryAxis::AxisLabelsPositionOnValue) {
                                 labelOnValue = true;
-                                labelItem->setPos(labelItem->pos().x(), upperBound - center.y());
+                                if (axis()->isReverse()) {
+                                    labelItem->setPos(labelItem->pos().x(), gridRect.top() + gridRect.bottom()
+                                                      - layout[i + 1] - center.y());
+                                } else {
+                                    labelItem->setPos(labelItem->pos().x(), upperBound - center.y());
+                                }
                             }
                         }
                     }
                     //label overlap detection - compensate one pixel for rounding errors
-                    if (labelItem->pos().y() + boundingRect.height() > height || forceHide ||
+                    if (axis()->isReverse()) {
+                        if (forceHide)
+                            labelItem->setVisible(false);
+                    } else if (labelItem->pos().y() + boundingRect.height() > height || forceHide ||
                         ((labelItem->pos().y() + (heightDiff / 2.0) - 1.0) > axisRect.bottom()
                          && !labelOnValue) ||
                         (labelItem->pos().y() + (heightDiff / 2.0) < (axisRect.top() - 1.0) && !labelOnValue)) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     //shades
                     QGraphicsRectItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at((i / 2) + 1));
                     if (shadeItem) {
                         qreal lowerBound;
                         qreal upperBound;
                         if (i == 0) {
-                            lowerBound = gridRect.bottom();
+                            if (axis()->isReverse()) {
-                            upperBound = layout[0];
-                        } else {
-                            lowerBound = layout[i];
-                            if (i == layout.size() - 1)
                                 upperBound = gridRect.top();
-                            else
+                                lowerBound = gridRect.top() + gridRect.bottom() - layout[i];
-                                upperBound = qMax(layout[i + 1], gridRect.top());
+                            } else {
+                                lowerBound = gridRect.bottom();
+                                upperBound = layout[0];
+                            }
+                        } else {
+                            if (axis()->isReverse()) {
+                                    upperBound = gridRect.top() + gridRect.bottom() - layout[i];
+                                if (i == layout.size() - 1) {
+                                    lowerBound = gridRect.bottom();
+                                } else {
+                                    lowerBound = qMax(gridRect.top() + gridRect.bottom() - layout[i + 1],
+                                            gridRect.top());
+                                }
+                            } else {
+                                lowerBound = layout[i];
+                                if (i == layout.size() - 1)
+                                    upperBound = gridRect.top();
+                                else
+                                    upperBound = qMax(layout[i + 1], gridRect.top());
+                            }
                         }
                         if (lowerBound > gridRect.bottom())
                             lowerBound = gridRect.bottom();
                         if (upperBound < gridRect.top())
                             upperBound = gridRect.top();
                         shadeItem->setRect(gridRect.left(), upperBound, gridRect.width(),
                                            lowerBound - upperBound);
                         if (shadeItem->rect().height() <= 0.0)
                             shadeItem->setVisible(false);
                         else
                             shadeItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal y = gridItem->line().p1().y();
                     if ((y < gridRect.top() || y > gridRect.bottom()))
                     {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     }else{
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size() + 1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF VerticalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0, 0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(),
                                                                         QStringLiteral("..."));
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QT_CHARTS_END_NAMESPACE

src/charts/chartitem.cpp +13 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/chartitem_p.h>
             #include <private/qabstractseries_p.h>
             #include <private/abstractdomain_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             ChartItem::ChartItem(QAbstractSeriesPrivate *series,QGraphicsItem* item):
                   ChartElement(item),
                   m_validData(true),
                   m_series(series)
             {
             }
             AbstractDomain* ChartItem::domain() const
             {
                 return m_series->domain();
             }
             void ChartItem::handleDomainUpdated()
             {
                 qWarning() <<  __FUNCTION__<< "Slot not implemented";
             }
+            void ChartItem::reversePainter(QPainter *painter, const QRectF &clipRect)
+            {
+                if (m_series->reverseXAxis()) {
+                    painter->translate(clipRect.width(), 0);
+                    painter->scale(-1, 1);
+                }
+                if (m_series->reverseYAxis()) {
+                    painter->translate(0, clipRect.height());
+                    painter->scale(1, -1);
+                }
+            }
             #include "moc_chartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartitem_p.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTITEM_H
             #define CHARTITEM_H
             #include <private/chartelement_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtWidgets/QGraphicsItem>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartItem : public ChartElement
             {
                 Q_OBJECT
                 enum ChartItemTypes { AXIS_ITEM = UserType + 1, XYLINE_ITEM };
             public:
                 ChartItem(QAbstractSeriesPrivate *series,QGraphicsItem* item);
                 AbstractDomain*  domain() const;
             public Q_SLOTS:
                 virtual void handleDomainUpdated();
+                void reversePainter(QPainter *painter, const QRectF &clipRect);
+                QAbstractSeriesPrivate* seriesPrivate() const {return m_series;}
             protected:
                 bool m_validData;
             private:
                 QAbstractSeriesPrivate* m_series;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTITEM_H */

src/charts/linechart/linechartitem.cpp +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/linechartitem_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/qlineseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/polardomain_p.h>
             #include <private/chartthememanager_p.h>
             #include <private/charttheme_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             const qreal mouseEventMinWidth(12);
             LineChartItem::LineChartItem(QLineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_chartType(QChart::ChartTypeUndefined),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_shapePath;
             }
             void LineChartItem::updateGeometry()
             {
                 m_points = geometryPoints();
                 const QVector<QPointF> &points = m_points;
                 if (points.size() == 0) {
                     prepareGeometryChange();
                     m_fullPath = QPainterPath();
                     m_linePath = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 QPainterPath linePath;
                 QPainterPath fullPath;
                 // Use worst case scenario to determine required margin.
                 qreal margin = m_linePen.width() * 1.42;
                 // Area series use component line series that aren't necessarily added to the chart themselves,
                 // so check if chart type is forced before trying to obtain it from the chart.
                 QChart::ChartType chartType = m_chartType;
                 if (chartType == QChart::ChartTypeUndefined)
                     chartType = m_series->chart()->chartType();
                 // For polar charts, we need special handling for angular (horizontal)
                 // points that are off-grid.
                 if (chartType == QChart::ChartTypePolar) {
                     QPainterPath linePathLeft;
                     QPainterPath linePathRight;
                     QPainterPath *currentSegmentPath = 0;
                     QPainterPath *previousSegmentPath = 0;
                     qreal minX = domain()->minX();
                     qreal maxX = domain()->maxX();
                     qreal minY = domain()->minY();
                     QPointF currentSeriesPoint = m_series->at(0);
                     QPointF currentGeometryPoint = points.at(0);
                     QPointF previousGeometryPoint = points.at(0);
                     int size = m_linePen.width();
                     bool pointOffGrid = false;
                     bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                     qreal domainRadius = domain()->size().height() / 2.0;
                     const QPointF centerPoint(domainRadius, domainRadius);
                     if (!previousPointWasOffGrid) {
                         fullPath.moveTo(points.at(0));
                         if (m_pointsVisible && currentSeriesPoint.y() >= minY) {
                             // Do not draw ellipses for points below minimum Y.
                             linePath.addEllipse(points.at(0), size, size);
                             fullPath.addEllipse(points.at(0), size, size);
                             linePath.moveTo(points.at(0));
                             fullPath.moveTo(points.at(0));
                         }
                     }
                     qreal leftMarginLine = centerPoint.x() - margin;
                     qreal rightMarginLine = centerPoint.x() + margin;
                     qreal horizontal = centerPoint.y();
                     // See ScatterChartItem::updateGeometry() for explanation why seriesLastIndex is needed
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 1; i < points.size(); i++) {
                         // Interpolating line fragments would be ugly when thick pen is used,
                         // so we work around it by utilizing three separate
                         // paths for line segments and clip those with custom regions at paint time.
                         // "Right" path contains segments that cross the axis line with visible point on the
                         // right side of the axis line, as well as segments that have one point within the margin
                         // on the right side of the axis line and another point on the right side of the chart.
                         // "Left" path contains points with similarly on the left side.
                         // "Full" path contains rest of the points.
                         // This doesn't yield perfect results always. E.g. when segment covers more than 90
                         // degrees and both of the points are within the margin, one in the top half and one in the
                         // bottom half of the chart, the bottom one gets clipped incorrectly.
                         // However, this should be rare occurrence in any sensible chart.
                         currentSeriesPoint = m_series->at(qMin(seriesLastIndex, i));
                         currentGeometryPoint = points.at(i);
                         pointOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                         // Draw something unless both off-grid
                         if (!pointOffGrid || !previousPointWasOffGrid) {
                             QPointF intersectionPoint;
                             qreal y;
                             if (pointOffGrid != previousPointWasOffGrid) {
                                 if (currentGeometryPoint.x() == previousGeometryPoint.x()) {
                                     y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) / 2.0;
                                 } else {
                                     qreal ratio = (centerPoint.x() - currentGeometryPoint.x()) / (currentGeometryPoint.x() - previousGeometryPoint.x());
                                     y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) * ratio;
                                 }
                                 intersectionPoint = QPointF(centerPoint.x(), y);
                             }
                             bool dummyOk; // We know points are ok, but this is needed
                             qreal currentAngle = 0;
                             qreal previousAngle = 0;
                             if (const PolarDomain *pd = qobject_cast<const PolarDomain *>(domain())) {
                                 currentAngle = pd->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
                                 previousAngle = pd->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
                             } else {
                                 qWarning() << Q_FUNC_INFO << "Unexpected domain: " << domain();
                             }
                             if ((qAbs(currentAngle - previousAngle) > 180.0)) {
                                 // If the angle between two points is over 180 degrees (half X range),
                                 // any direct segment between them becomes meaningless.
                                 // In this case two line segments are drawn instead, from previous
                                 // point to the center and from center to current point.
                                 if ((previousAngle < 0.0 || (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
                                     && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathRight;
                                 } else if ((previousAngle > 360.0 || (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
                                             && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathLeft;
                                 } else if (previousAngle > 0.0 && previousAngle < 360.0) {
                                     currentSegmentPath = &linePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(previousGeometryPoint);
                                     if (previousPointWasOffGrid)
                                         fullPath.moveTo(intersectionPoint);
                                     currentSegmentPath->lineTo(centerPoint);
                                     fullPath.lineTo(centerPoint);
                                 }
                                 previousSegmentPath = currentSegmentPath;
                                 if ((currentAngle < 0.0 || (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
                                     && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathRight;
                                 } else if ((currentAngle > 360.0 || (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
                                             && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathLeft;
                                 } else if (currentAngle > 0.0 && currentAngle < 360.0) {
                                     currentSegmentPath = &linePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(centerPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(centerPoint);
                                     currentSegmentPath->lineTo(currentGeometryPoint);
                                     if (pointOffGrid)
                                         fullPath.lineTo(intersectionPoint);
                                     else
                                         fullPath.lineTo(currentGeometryPoint);
                                 }
                             } else {
                                 if (previousAngle < 0.0 || currentAngle < 0.0
                                     || ((previousAngle <= 180.0 && currentAngle <= 180.0)
                                         && ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
                                             || (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &linePathRight;
                                 } else if (previousAngle > 360.0 || currentAngle > 360.0
                                            || ((previousAngle > 180.0 && currentAngle > 180.0)
                                                && ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
                                                    || (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &linePathLeft;
                                 } else {
                                     currentSegmentPath = &linePath;
                                 }
                                 if (currentSegmentPath != previousSegmentPath)
                                     currentSegmentPath->moveTo(previousGeometryPoint);
                                 if (previousPointWasOffGrid)
                                     fullPath.moveTo(intersectionPoint);
                                 if (pointOffGrid)
                                     fullPath.lineTo(intersectionPoint);
                                 else
                                     fullPath.lineTo(currentGeometryPoint);
                                 currentSegmentPath->lineTo(currentGeometryPoint);
                             }
                         } else {
                             currentSegmentPath = 0;
                         }
                         previousPointWasOffGrid = pointOffGrid;
                         if (m_pointsVisible && !pointOffGrid && currentSeriesPoint.y() >= minY) {
                             linePath.addEllipse(points.at(i), size, size);
                             fullPath.addEllipse(points.at(i), size, size);
                             linePath.moveTo(points.at(i));
                             fullPath.moveTo(points.at(i));
                         }
                         previousSegmentPath = currentSegmentPath;
                         previousGeometryPoint = currentGeometryPoint;
                     }
                     m_linePathPolarRight = linePathRight;
                     m_linePathPolarLeft = linePathLeft;
                     // Note: This construction of m_fullpath is not perfect. The partial segments that are
                     // outside left/right clip regions at axis boundary still generate hover/click events,
                     // because shape doesn't get clipped. It doesn't seem possible to do sensibly.
                 } else { // not polar
                     linePath.moveTo(points.at(0));
                     if (m_pointsVisible) {
                         int size = m_linePen.width();
                         linePath.addEllipse(points.at(0), size, size);
                         linePath.moveTo(points.at(0));
                         for (int i = 1; i < points.size(); i++) {
                             linePath.lineTo(points.at(i));
                             linePath.addEllipse(points.at(i), size, size);
                             linePath.moveTo(points.at(i));
                         }
                     } else {
                         for (int i = 1; i < points.size(); i++)
                             linePath.lineTo(points.at(i));
                     }
                     fullPath = linePath;
                 }
                 QPainterPathStroker stroker;
                 // QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
                 // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
                 // multiply line width with square root of two when defining shape and bounding rectangle.
                 stroker.setWidth(margin);
                 stroker.setJoinStyle(Qt::MiterJoin);
                 stroker.setCapStyle(Qt::SquareCap);
                 stroker.setMiterLimit(m_linePen.miterLimit());
                 QPainterPath checkShapePath = stroker.createStroke(fullPath);
                 // Only zoom in if the bounding rects of the paths fit inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (checkShapePath.boundingRect().height() <= INT_MAX
                         && checkShapePath.boundingRect().width() <= INT_MAX
                         && linePath.boundingRect().height() <= INT_MAX
                         && linePath.boundingRect().width() <= INT_MAX
                         && fullPath.boundingRect().height() <= INT_MAX
                         && fullPath.boundingRect().width() <= INT_MAX) {
                     prepareGeometryChange();
                     m_linePath = linePath;
                     m_fullPath = fullPath;
                     m_shapePath = checkShapePath;
                     m_rect = m_shapePath.boundingRect();
                 } else {
                     update();
                 }
             }
             void LineChartItem::handleUpdated()
             {
                 // If points visibility has changed, a geometry update is needed.
                 // Also, if pen changes when points are visible, geometry update is needed.
                 bool doGeometryUpdate =
                     (m_pointsVisible != m_series->pointsVisible())
                     || (m_series->pointsVisible() && (m_linePen != m_series->pen()));
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 if (doGeometryUpdate)
                     updateGeometry();
                 update();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setPen(m_linePen);
                 bool alwaysUsePath = false;
                 if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
                     qreal halfWidth = domain()->size().width() / 2.0;
                     QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
                     QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
                     QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
                     QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
                     QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
                     painter->setClipRegion(clipRegionLeft);
                     painter->drawPath(m_linePathPolarLeft);
                     painter->setClipRegion(clipRegionRight);
                     painter->drawPath(m_linePathPolarRight);
                     painter->setClipRegion(fullPolarClipRegion);
                     alwaysUsePath = true; // required for proper clipping
                 } else {
                     painter->setClipRect(clipRect);
                 }
+                reversePainter(painter, clipRect);
                 if (m_pointsVisible) {
                     painter->setBrush(m_linePen.color());
                     painter->drawPath(m_linePath);
                 } else {
                     painter->setBrush(QBrush(Qt::NoBrush));
                     if (m_linePen.style() != Qt::SolidLine || alwaysUsePath) {
                         // If pen style is not solid line, always fall back to path painting
                         // to ensure proper continuity of the pattern
                         painter->drawPath(m_linePath);
                     } else {
                         for (int i(1); i < m_points.size(); i++)
                             painter->drawLine(m_points.at(i - 1), m_points.at(i));
                     }
                 }
+                reversePainter(painter, clipRect);
                 if (m_pointLabelsVisible)
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points, m_linePen.width() / 2);
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 QGraphicsItem::mousePressEvent(event);
             }
             void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
                 if (m_mousePressed)
                     emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/qabstractseries.cpp +34 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractSeries>
             #include <private/qabstractseries_p.h>
             #include <private/chartdataset_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \inmodule Qt Charts
                 \brief Base class for all Qt Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmltype AbstractSeries
                 \instantiates QAbstractSeries
                 \inqmlmodule QtCharts
                 \brief Base class for all Qt Chart series.
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
                 \value SeriesTypeBoxPlot
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \internal
                 \brief Constructs QAbstractSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Series still bound to a chart when destroyed!");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 \brief Sets the visibility of the series to true.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \note If multiple axes of same orientation are attached to same series,
                    they will have same min/max ranges.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::setPresenter(ChartPresenter *presenter)
             {
                 m_presenter = presenter;
             }
             ChartPresenter *QAbstractSeriesPrivate::presenter() const
             {
                 return m_presenter;
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_UNUSED(options);
             }
+            bool QAbstractSeriesPrivate::reverseXAxis()
+            {
+                bool reverseXAxis = false;
+                if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
+                    int i = 0;
+                    while (i < m_axes.size()) {
+                        if (m_axes.at(i)->orientation() == Qt::Horizontal && m_axes.at(i)->isReverse()) {
+                            reverseXAxis = true;
+                            break;
+                        }
+                        i++;
+                    }
+                }
+                return reverseXAxis;
+            }
+            bool QAbstractSeriesPrivate::reverseYAxis()
+            {
+                bool reverseYAxis = false;
+                if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
+                    int i = 0;
+                    while (i < m_axes.size()) {
+                        if (m_axes.at(i)->orientation() == Qt::Vertical && m_axes.at(i)->isReverse()) {
+                            reverseYAxis = true;
+                            break;
+                        }
+                        i++;
+                    }
+                }
+                return reverseYAxis;
+            }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/qabstractseries_p.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include <QtCharts/QAbstractSeries>
             #include <QtCharts/QChart>
             #include <private/abstractdomain_p.h>
             QT_BEGIN_NAMESPACE
             class QGraphicsItem;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartElement;
             class LegendMarker;
             class QLegend;
             class ChartDataSet;
             class QAbstractAxis;
             class QLegendMarker;
             class ChartTheme;
             class ChartAnimation;
             class ChartItem;
             class BoxPlotChartItem;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void initializeDomain() = 0;
                 virtual void initializeAxes() = 0;
                 virtual void initializeTheme(int index, ChartTheme* theme, bool forced = false) = 0;
                 virtual void initializeGraphics(QGraphicsItem* parent) = 0;
                 virtual void initializeAnimations(QChart::AnimationOptions options) = 0;
                 virtual QList<QLegendMarker*> createLegendMarkers(QLegend* legend) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
                 virtual QAbstractAxis* createDefaultAxis(Qt::Orientation) const = 0;
                 ChartItem* chartItem() { return m_item.data(); }
                 virtual void setDomain(AbstractDomain* domain);
                 AbstractDomain* domain() { return m_domain.data(); }
                 virtual void setPresenter(ChartPresenter *presenter);
                 ChartPresenter *presenter() const;
                 QChart* chart() { return m_chart; }
+                bool reverseXAxis();
+                bool reverseYAxis();
             Q_SIGNALS:
                 void countChanged();
             protected:
                 QAbstractSeries *q_ptr;
                 QChart *m_chart;
                 QScopedPointer<ChartItem> m_item;
                 QList<QAbstractAxis*> m_axes;
             private:
                 QScopedPointer<AbstractDomain> m_domain;
                 QString m_name;
                 bool m_visible;
                 qreal m_opacity;
                 ChartPresenter *m_presenter;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
                 friend class BoxPlotChartItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/charts/scatterchart/scatterchartitem.cpp +11 -1

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/scatterchartitem_p.h>
             #include <QtCharts/QScatterSeries>
             #include <private/qscatterseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QChart>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsScene>
             #include <QtCore/QDebug>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_items(this),
                   m_visible(true),
                   m_shape(QScatterSeries::MarkerShapeRectangle),
                   m_size(15),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                     case QScatterSeries::MarkerShapeCircle: {
                         item = new CircleMarker(0, 0, m_size, m_size, this);
                         const QRectF &rect = item->boundingRect();
                         item->setPos(-rect.width() / 2, -rect.height() / 2);
                         break;
                     }
                     case QScatterSeries::MarkerShapeRectangle:
                         item = new RectangleMarker(0, 0, m_size, m_size, this);
                         item->setPos(-m_size / 2, -m_size / 2);
                         break;
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
             }
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
                 emit XYChart::clicked(m_markerMap[marker]);
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
                 emit XYChart::hovered(m_markerMap[marker], state);
             }
             void ScatterChartItem::markerPressed(QGraphicsItem *marker)
             {
                 emit XYChart::pressed(m_markerMap[marker]);
             }
             void ScatterChartItem::markerReleased(QGraphicsItem *marker)
             {
                 emit XYChart::released(m_markerMap[marker]);
             }
             void ScatterChartItem::markerDoubleClicked(QGraphicsItem *marker)
             {
                 emit XYChart::doubleClicked(m_markerMap[marker]);
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if (points.size() == 0) {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if (diff > 0)
                     deletePoints(diff);
                 else if (diff < 0)
                     createPoints(-diff);
                 if (diff != 0)
                     handleUpdated();
                 QList<QGraphicsItem *> items = m_items.childItems();
                 QRectF clipRect(QPointF(0,0),domain()->size());
                 // Only zoom in if the clipRect fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (clipRect.height() <= INT_MAX
                         && clipRect.width() <= INT_MAX) {
                     QVector<bool> offGridStatus = offGridStatusVector();
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 0; i < points.size(); i++) {
                         QGraphicsItem *item = items.at(i);
                         const QPointF &point = points.at(i);
                         const QRectF &rect = item->boundingRect();
                         // During remove animation series may have different number of points,
                         // so ensure we don't go over the index. Animation handling itself ensures that
                         // if there is actually no points in the series, then it won't generate a fake point,
                         // so we can be assured there is always at least one point in m_series here.
                         // Note that marker map values can be technically incorrect during the animation,
                         // if it was caused by an insert, but this shouldn't be a problem as the points are
                         // fake anyway. After remove animation stops, geometry is updated to correct one.
                         m_markerMap[item] = m_series->at(qMin(seriesLastIndex, i));
-                        item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
+                        QPointF position;
+                        if (seriesPrivate()->reverseXAxis())
+                            position.setX(domain()->size().width() - point.x() - rect.width() / 2);
+                        else
+                            position.setX(point.x() - rect.width() / 2);
+                        if (seriesPrivate()->reverseYAxis())
+                            position.setY(domain()->size().height() - point.y() - rect.height() / 2);
+                        else
+                            position.setY(point.y() - rect.height() / 2);
+                        item->setPos(position);
                         if (!m_visible || offGridStatus.at(i))
                             item->setVisible(false);
                         else
                             item->setVisible(true);
                     }
                     prepareGeometryChange();
                     m_rect = clipRect;
                 }
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setClipRect(clipRect);
                 if (m_pointLabelsVisible) {
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points,
                                                               m_series->markerSize() / 2
                                                               + m_series->pen().width());
                 }
                 painter->restore();
             }
             void ScatterChartItem::setPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
             void ScatterChartItem::setBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if (count == 0)
                     return;
                 bool recreate = m_visible != m_series->isVisible()
                                 || m_size != m_series->markerSize()
                                 || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 if (recreate) {
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             #include "moc_scatterchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/splinechart/splinechartitem.cpp +4 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/splinechartitem_p.h>
             #include <private/qsplineseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/splineanimation_p.h>
             #include <private/polardomain_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_animation(0),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 setZValue(ChartPresenter::SplineChartZValue);
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_fullPath;
             }
             void SplineChartItem::setAnimation(SplineAnimation *animation)
             {
                 m_animation = animation;
                 XYChart::setAnimation(animation);
             }
             ChartAnimation *SplineChartItem::animation() const
             {
                 return m_animation;
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints = points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 QVector<QPointF> controlPoints;
                 if (newPoints.count() >= 2)
                     controlPoints = calculateControlPoints(newPoints);
                 if (m_animation)
                     m_animation->setup(oldPoints, newPoints, m_controlPoints, controlPoints, index);
                 m_points = newPoints;
                 m_controlPoints = controlPoints;
                 setDirty(false);
                 if (m_animation)
                     presenter()->startAnimation(m_animation);
                 else
                     updateGeometry();
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = m_points;
                 const QVector<QPointF> &controlPoints = m_controlPoints;
                 if ((points.size() < 2) || (controlPoints.size() < 2)) {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count() * 2 - 2 == controlPoints.count());
                 QPainterPath splinePath;
                 QPainterPath fullPath;
                 // Use worst case scenario to determine required margin.
                 qreal margin = m_linePen.width() * 1.42;
                 if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
                     QPainterPath splinePathLeft;
                     QPainterPath splinePathRight;
                     QPainterPath *currentSegmentPath = 0;
                     QPainterPath *previousSegmentPath = 0;
                     qreal minX = domain()->minX();
                     qreal maxX = domain()->maxX();
                     qreal minY = domain()->minY();
                     QPointF currentSeriesPoint = m_series->at(0);
                     QPointF currentGeometryPoint = points.at(0);
                     QPointF previousGeometryPoint = points.at(0);
                     bool pointOffGrid = false;
                     bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                     m_visiblePoints.clear();
                     m_visiblePoints.reserve(points.size());
                     qreal domainRadius = domain()->size().height() / 2.0;
                     const QPointF centerPoint(domainRadius, domainRadius);
                     if (!previousPointWasOffGrid) {
                         fullPath.moveTo(points.at(0));
                         // Do not draw points for points below minimum Y.
                         if (m_pointsVisible && currentSeriesPoint.y() >= minY)
                             m_visiblePoints.append(currentGeometryPoint);
                     }
                     qreal leftMarginLine = centerPoint.x() - margin;
                     qreal rightMarginLine = centerPoint.x() + margin;
                     qreal horizontal = centerPoint.y();
                     // See ScatterChartItem::updateGeometry() for explanation why seriesLastIndex is needed
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 1; i < points.size(); i++) {
                         // Interpolating spline fragments accurately is not trivial, and would anyway be ugly
                         // when thick pen is used, so we work around it by utilizing three separate
                         // paths for spline segments and clip those with custom regions at paint time.
                         // "Right" path contains segments that cross the axis line with visible point on the
                         // right side of the axis line, as well as segments that have one point within the margin
                         // on the right side of the axis line and another point on the right side of the chart.
                         // "Left" path contains points with similarly on the left side.
                         // "Full" path contains rest of the points.
                         // This doesn't yield perfect results always. E.g. when segment covers more than 90
                         // degrees and both of the points are within the margin, one in the top half and one in the
                         // bottom half of the chart, the bottom one gets clipped incorrectly.
                         // However, this should be rare occurrence in any sensible chart.
                         currentSeriesPoint = m_series->at(qMin(seriesLastIndex, i));
                         currentGeometryPoint = points.at(i);
                         pointOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                         // Draw something unless both off-grid
                         if (!pointOffGrid || !previousPointWasOffGrid) {
                             bool dummyOk; // We know points are ok, but this is needed
                             qreal currentAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
                             qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
                             if ((qAbs(currentAngle - previousAngle) > 180.0)) {
                                 // If the angle between two points is over 180 degrees (half X range),
                                 // any direct segment between them becomes meaningless.
                                 // In this case two line segments are drawn instead, from previous
                                 // point to the center and from center to current point.
                                 if ((previousAngle < 0.0 || (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
                                     && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathRight;
                                 } else if ((previousAngle > 360.0 || (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
                                             && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathLeft;
                                 } else if (previousAngle > 0.0 && previousAngle < 360.0) {
                                     currentSegmentPath = &splinePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(previousGeometryPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(previousGeometryPoint);
                                     currentSegmentPath->lineTo(centerPoint);
                                     fullPath.lineTo(centerPoint);
                                 }
                                 previousSegmentPath = currentSegmentPath;
                                 if ((currentAngle < 0.0 || (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
                                     && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathRight;
                                 } else if ((currentAngle > 360.0 || (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
                                             && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &splinePathLeft;
                                 } else if (currentAngle > 0.0 && currentAngle < 360.0) {
                                     currentSegmentPath = &splinePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(centerPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(centerPoint);
                                     currentSegmentPath->lineTo(currentGeometryPoint);
                                     fullPath.lineTo(currentGeometryPoint);
                                 }
                             } else {
                                 QPointF cp1 = controlPoints[2 * (i - 1)];
                                 QPointF cp2 = controlPoints[(2 * i) - 1];
                                 if (previousAngle < 0.0 || currentAngle < 0.0
                                     || ((previousAngle <= 180.0 && currentAngle <= 180.0)
                                         && ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
                                             || (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &splinePathRight;
                                 } else if (previousAngle > 360.0 || currentAngle > 360.0
                                            || ((previousAngle > 180.0 && currentAngle > 180.0)
                                                && ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
                                                    || (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &splinePathLeft;
                                 } else {
                                     currentSegmentPath = &splinePath;
                                 }
                                 if (currentSegmentPath != previousSegmentPath)
                                     currentSegmentPath->moveTo(previousGeometryPoint);
                                 if (!previousSegmentPath)
                                     fullPath.moveTo(previousGeometryPoint);
                                 fullPath.cubicTo(cp1, cp2, currentGeometryPoint);
                                 currentSegmentPath->cubicTo(cp1, cp2, currentGeometryPoint);
                             }
                         } else {
                             currentSegmentPath = 0;
                         }
                         previousPointWasOffGrid = pointOffGrid;
                         if (!pointOffGrid && m_pointsVisible && currentSeriesPoint.y() >= minY)
                             m_visiblePoints.append(currentGeometryPoint);
                         previousSegmentPath = currentSegmentPath;
                         previousGeometryPoint = currentGeometryPoint;
                     }
                     m_pathPolarRight = splinePathRight;
                     m_pathPolarLeft = splinePathLeft;
                     // Note: This construction of m_fullpath is not perfect. The partial segments that are
                     // outside left/right clip regions at axis boundary still generate hover/click events,
                     // because shape doesn't get clipped. It doesn't seem possible to do sensibly.
                 } else { // not polar
                     splinePath.moveTo(points.at(0));
                     for (int i = 0; i < points.size() - 1; i++) {
                         const QPointF &point = points.at(i + 1);
                         splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);
                     }
                     fullPath = splinePath;
                 }
                 QPainterPathStroker stroker;
                 // The full path is comprised of three separate paths.
                 // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
                 // multiply line width with square root of two when defining shape and bounding rectangle.
                 stroker.setWidth(margin);
                 stroker.setJoinStyle(Qt::MiterJoin);
                 stroker.setCapStyle(Qt::SquareCap);
                 stroker.setMiterLimit(m_linePen.miterLimit());
                 // Only zoom in if the bounding rects of the path fit inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 QPainterPath checkShapePath = stroker.createStroke(fullPath);
                 if (checkShapePath.boundingRect().height() <= INT_MAX
                         && checkShapePath.boundingRect().width() <= INT_MAX
                         && splinePath.boundingRect().height() <= INT_MAX
                         && splinePath.boundingRect().width() <= INT_MAX) {
                     m_path = splinePath;
                     prepareGeometryChange();
                     m_fullPath = checkShapePath;
                     m_rect = m_fullPath.boundingRect();
                 }
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             QVector<QPointF> SplineChartItem::calculateControlPoints(const QVector<QPointF> &points)
             {
                 QVector<QPointF> controlPoints;
                 controlPoints.resize(points.count() * 2 - 2);
                 int n = points.count() - 1;
                 if (n == 1) {
                     //for n==1
                     controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     controlPoints[1].setX(2 * controlPoints[0].x() - points[0].x());
                     controlPoints[1].setY(2 * controlPoints[0].y() - points[0].y());
                     return controlPoints;
                 }
                 // Calculate first Bezier control points
                 // Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 vector[n - 1] = (8 * points[n - 1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 vector[n - 1] = (8 * points[n - 1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0, j = 0; i < n; ++i, ++j) {
                     controlPoints[j].setX(xControl[i]);
                     controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1) {
                         controlPoints[j].setX(2 * points[i + 1].x() - xControl[i + 1]);
                         controlPoints[j].setY(2 * points[i + 1].y() - yControl[i + 1]);
                     } else {
                         controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
                 return controlPoints;
             }
             QVector<qreal> SplineChartItem::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i] = (vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(Qt::NoBrush);
                 if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
                     qreal halfWidth = domain()->size().width() / 2.0;
                     QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
                     QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
                     QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
                     QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
                     QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
                     painter->setClipRegion(clipRegionLeft);
                     painter->drawPath(m_pathPolarLeft);
                     painter->setClipRegion(clipRegionRight);
                     painter->drawPath(m_pathPolarRight);
                     painter->setClipRegion(fullPolarClipRegion);
                 } else {
                     painter->setClipRect(clipRect);
                 }
+                reversePainter(painter, clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     if (m_series->chart()->chartType() == QChart::ChartTypePolar)
                         painter->drawPoints(m_visiblePoints);
                     else
                         painter->drawPoints(geometryPoints());
                 }
+                reversePainter(painter, clipRect);
                 if (m_pointLabelsVisible)
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points, m_linePen.width() / 2);
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 QGraphicsItem::mousePressEvent(event);
             }
             void SplineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void SplineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
                 QGraphicsItem::hoverLeaveEvent(event);
             }
             void SplineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
                 if (m_mousePressed)
                     emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void SplineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/xychart/qxyseries.cpp +8 -2

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QXYSeries>
             #include <private/qxyseries_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QValueAxis>
             #include <private/xychart_p.h>
             #include <QtCharts/QXYLegendMarker>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             #include <QtGui/QPainter>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \inmodule Qt Charts
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmltype XYSeries
                 \instantiates QXYSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The XYSeries type is a base type for line, spline and scatter series.
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \property QXYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QXYSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa QXYSeries::pointLabelsVisible, QXYSeries::pointLabelsFont, QXYSeries::pointLabelsColor
             */
             /*!
                 \qmlproperty string XYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa QXYSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QXYSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QXYSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty bool XYSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QXYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QXYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa QXYSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart. The \a point is the point
                 where the press was triggered.
                 \sa pressed, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. The \a point is the point where the
                 press was triggered. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onPressed, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pressed(const QPointF& point)
                 \brief Signal is emitted when user presses the \a point on chart.
                 \sa clicked, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onPressed(QPointF point)
                 Signal is emitted when user presses the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onPressed: console.log("onPressed: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onClicked, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::released(const QPointF& point)
                 \brief Signal is emitted when user releases a press that was triggered on a \a point on chart.
                 \sa pressed, clicked, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onReleased(QPointF point)
                 Signal is emitted when user releases a press that was triggered on a \a point on chart.
                 For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onReleased: console.log("onReleased: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onPressed, onClicked, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::doubleClicked(const QPointF& point)
                 \brief Signal is emitted when user doubleclicks the \a point on chart. The \a point is the
                 point where the first press was triggered.
                 \sa pressed, released, clicked
             */
             /*!
                 \qmlsignal XYSeries::onDoubleClicked(QPointF point)
                 Signal is emitted when user doubleclicks the \a point on chart. The \a point is the point where
                 the first press was triggered. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onDoubleClicked: console.log("onDoubleClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onPressed, onReleased, onClicked
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with other points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
                 Signal is emitted when all points have been replaced with other points.
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point (\a oldX, \a oldY) with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
                 replace(index, newPoint);
             }
             /*!
               Replaces the point at \a index with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, qreal newX, qreal newY)
             {
                 replace(index, QPointF(newX, newY));
             }
             /*!
               Replaces the point at \a index with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(int index, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points.
               \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 remove(index);
             }
             /*!
               Removes the point at \a index from the series.
             */
             void QXYSeries::remove(int index)
             {
                 Q_D(QXYSeries);
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     index = qMax(0, qMin(index, d->m_points.size()));
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             void QXYSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QXYSeries::pointLabelsFormat() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFormat;
             }
             void QXYSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QXYSeries::pointLabelsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsVisible;
             }
             void QXYSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QXYSeries::pointLabelsFont() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFont;
             }
             void QXYSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QXYSeries::pointLabelsColor() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color())
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return new QValueAxis;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new XYAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             void QXYSeriesPrivate::drawSeriesPointLabels(QPainter *painter, const QVector<QPointF> &points,
                                                          const int offset)
             {
                 static const QString xPointTag(QLatin1String("@xPoint"));
                 static const QString yPointTag(QLatin1String("@yPoint"));
                 const int labelOffset = offset + 2;
                 painter->setFont(m_pointLabelsFont);
                 painter->setPen(QPen(m_pointLabelsColor));
                 QFontMetrics fm(painter->font());
                 // m_points is used for the label here as it has the series point information
                 // points variable passed is used for positioning because it has the coordinates
                 for (int i(0); i < m_points.size(); i++) {
                     QString pointLabel = m_pointLabelsFormat;
                     pointLabel.replace(xPointTag, presenter()->numberToString(m_points.at(i).x()));
                     pointLabel.replace(yPointTag, presenter()->numberToString(m_points.at(i).y()));
                     // Position text in relation to the point
                     int pointLabelWidth = fm.width(pointLabel);
                     QPointF position(points.at(i));
-                    position.setX(position.x() - pointLabelWidth / 2);
+                    if (!reverseXAxis())
-                    position.setY(position.y() - labelOffset);
+                        position.setX(position.x() - pointLabelWidth / 2);
+                    else
+                        position.setX(domain()->size().width() - position.x() - pointLabelWidth / 2);
+                    if (!reverseYAxis())
+                        position.setY(position.y() - labelOffset);
+                    else
+                        position.setY(domain()->size().height() - position.y() - labelOffset);
                     painter->drawText(position, pointLabel);
                 }
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/chartsqml2_plugin.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QChart>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include "declarativecategoryaxis.h"
             #include <QtCharts/QBarCategoryAxis>
             #include "declarativechart.h"
             #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativepieseries.h"
             #include "declarativeaxes.h"
             #include <QtCharts/QVXYModelMapper>
             #include <QtCharts/QHXYModelMapper>
             #include <QtCharts/QHPieModelMapper>
             #include <QtCharts/QVPieModelMapper>
             #include <QtCharts/QHBarModelMapper>
             #include <QtCharts/QVBarModelMapper>
             #include "declarativemargins.h"
             #include <QtCharts/QAreaLegendMarker>
             #include <QtCharts/QBarLegendMarker>
             #include <QtCharts/QPieLegendMarker>
             #include <QtCharts/QXYLegendMarker>
             #include <QtCharts/QBoxPlotModelMapper>
             #include <QtCharts/QVBoxPlotModelMapper>
             #ifndef QT_ON_ARM
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtCore/QAbstractItemModel>
             #include <QtQml>
             QT_CHARTS_USE_NAMESPACE
             QML_DECLARE_TYPE(QList<QPieSlice *>)
             QML_DECLARE_TYPE(QList<QBarSet *>)
             QML_DECLARE_TYPE(QList<QAbstractAxis *>)
             QML_DECLARE_TYPE(DeclarativeChart)
             QML_DECLARE_TYPE(DeclarativePolarChart)
             QML_DECLARE_TYPE(DeclarativeMargins)
             QML_DECLARE_TYPE(DeclarativeAreaSeries)
             QML_DECLARE_TYPE(DeclarativeBarSeries)
             QML_DECLARE_TYPE(DeclarativeBarSet)
             QML_DECLARE_TYPE(DeclarativeBoxPlotSeries)
             QML_DECLARE_TYPE(DeclarativeBoxSet)
             QML_DECLARE_TYPE(DeclarativeLineSeries)
             QML_DECLARE_TYPE(DeclarativePieSeries)
             QML_DECLARE_TYPE(DeclarativePieSlice)
             QML_DECLARE_TYPE(DeclarativeScatterSeries)
             QML_DECLARE_TYPE(DeclarativeSplineSeries)
             QML_DECLARE_TYPE(QAbstractAxis)
             QML_DECLARE_TYPE(QValueAxis)
             QML_DECLARE_TYPE(QBarCategoryAxis)
             QML_DECLARE_TYPE(QCategoryAxis)
             QML_DECLARE_TYPE(QDateTimeAxis)
             QML_DECLARE_TYPE(QLogValueAxis)
             QML_DECLARE_TYPE(QLegend)
             QML_DECLARE_TYPE(QLegendMarker)
             QML_DECLARE_TYPE(QAreaLegendMarker)
             QML_DECLARE_TYPE(QBarLegendMarker)
             QML_DECLARE_TYPE(QPieLegendMarker)
             QML_DECLARE_TYPE(QHPieModelMapper)
             QML_DECLARE_TYPE(QHXYModelMapper)
             QML_DECLARE_TYPE(QPieModelMapper)
             QML_DECLARE_TYPE(QHBarModelMapper)
             QML_DECLARE_TYPE(QBarModelMapper)
             QML_DECLARE_TYPE(QVBarModelMapper)
             QML_DECLARE_TYPE(QVPieModelMapper)
             QML_DECLARE_TYPE(QVXYModelMapper)
             QML_DECLARE_TYPE(QXYLegendMarker)
             QML_DECLARE_TYPE(QXYModelMapper)
             QML_DECLARE_TYPE(QBoxPlotModelMapper)
             QML_DECLARE_TYPE(QVBoxPlotModelMapper)
             QML_DECLARE_TYPE(QAbstractSeries)
             QML_DECLARE_TYPE(QXYSeries)
             QML_DECLARE_TYPE(QAbstractBarSeries)
             QML_DECLARE_TYPE(QBarSeries)
             QML_DECLARE_TYPE(QBarSet)
             QML_DECLARE_TYPE(QAreaSeries)
             QML_DECLARE_TYPE(QHorizontalBarSeries)
             QML_DECLARE_TYPE(QHorizontalPercentBarSeries)
             QML_DECLARE_TYPE(QHorizontalStackedBarSeries)
             QML_DECLARE_TYPE(QLineSeries)
             QML_DECLARE_TYPE(QPercentBarSeries)
             QML_DECLARE_TYPE(QPieSeries)
             QML_DECLARE_TYPE(QPieSlice)
             QML_DECLARE_TYPE(QScatterSeries)
             QML_DECLARE_TYPE(QSplineSeries)
             QML_DECLARE_TYPE(QStackedBarSeries)
             QT_CHARTS_BEGIN_NAMESPACE
             class QtChartsQml2Plugin : public QQmlExtensionPlugin
             {
                 Q_OBJECT
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCharts"));
                     // @uri QtCharts
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     qRegisterMetaType<QList<QAbstractAxis *> >();
                     // QtCharts 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 1, 0, "DeclarativeAxes",
                                                            QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     // QtCharts 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCharts 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 2>(uri, 1, 2, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 2>(uri, 1, 2, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 2>(uri, 1, 2, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 2>(uri, 1, 2, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 1, 2, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 1, 2, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 1, 2, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
                     // QtCharts 1.3
                     qmlRegisterType<DeclarativeChart, 3>(uri, 1, 3, "ChartView");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
                     qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                     qmlRegisterType<QLogValueAxis>(uri, 1, 3, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries>(uri, 1, 3, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet>(uri, 1, 3, "BoxSet");
                     // QtCharts 1.4
                     qmlRegisterType<DeclarativeAreaSeries, 4>(uri, 1, 4, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSet, 2>(uri, 1, 4, "BarSet");
                     qmlRegisterType<DeclarativeBoxPlotSeries, 1>(uri, 1, 4, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet, 1>(uri, 1, 4, "BoxSet");
                     qmlRegisterType<DeclarativePieSlice>(uri, 1, 4, "PieSlice");
                     qmlRegisterType<DeclarativeScatterSeries, 4>(uri, 1, 4, "ScatterSeries");
                     // QtCharts 2.0
                     qmlRegisterType<QVBoxPlotModelMapper>(uri, 2, 0, "VBoxPlotModelMapper");
                     qmlRegisterUncreatableType<QBoxPlotModelMapper>(uri, 2, 0, "BoxPlotModelMapper",
                         QLatin1String("Trying to create uncreatable: BoxPlotModelMapper."));
                     qmlRegisterType<DeclarativeChart, 4>(uri, 2, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 2, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries, 4>(uri, 2, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 2, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 2, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 4>(uri, 2, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 2, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 2, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 2, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 2, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 2, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet, 2>(uri, 2, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 2, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 2, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 2, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 2, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 2, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 2, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 2, 0, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 2, 0, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 2, 0, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 2, 0, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 2, 0, "BarCategoryAxis");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 2, 0, "PolarChartView");
                     qmlRegisterType<QLogValueAxis, 1>(uri, 2, 0, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries, 1>(uri, 2, 0, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet, 1>(uri, 2, 0, "BoxSet");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 2, 0, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 2, 0, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 2, 0, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSlice>(uri, 2, 0, "PieSlice");
                     qmlRegisterUncreatableType<QLegend>(uri, 2, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 2, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 2, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 2, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 2, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 2, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 2, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 2, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 2, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 2, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 2, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 2, 0, "DeclarativeAxes",
                                                                 QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 2, 0, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCharts 2.1
                     qmlRegisterType<DeclarativeCategoryAxis, 1>(uri, 2, 1, "CategoryAxis");
+                    qmlRegisterUncreatableType<QAbstractAxis>(uri, 2, 1, "AbstractAxis",
+                                                              QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                 }
             };
             QT_CHARTS_END_NAMESPACE
             #include "chartsqml2_plugin.moc"
             QT_CHARTS_USE_NAMESPACE

src/chartsqml2/plugins.qmltypes +11 -2

             import QtQuick.tooling 1.1
             // This file describes the plugin-supplied types contained in the library.
             // It is used for QML tooling purposes only.
             //
             // This file was auto-generated by:
             // 'qmlplugindump -nonrelocatable QtCharts 2.0'
             Module {
                 Component {
                     name: "QGraphicsObject"
                     defaultProperty: "children"
                     prototype: "QObject"
                     Property { name: "parent"; type: "QGraphicsObject"; isPointer: true }
                     Property { name: "opacity"; type: "double" }
                     Property { name: "enabled"; type: "bool" }
                     Property { name: "visible"; type: "bool" }
                     Property { name: "pos"; type: "QPointF" }
                     Property { name: "x"; type: "double" }
                     Property { name: "y"; type: "double" }
                     Property { name: "z"; type: "double" }
                     Property { name: "rotation"; type: "double" }
                     Property { name: "scale"; type: "double" }
                     Property { name: "transformOriginPoint"; type: "QPointF" }
                     Property { name: "effect"; type: "QGraphicsEffect"; isPointer: true }
                     Property {
                         name: "children"
                         type: "QDeclarativeListProperty<QGraphicsObject>"
                         isReadonly: true
                     }
                     Property { name: "width"; type: "double" }
                     Property { name: "height"; type: "double" }
                 }
                 Component {
                     name: "QGraphicsWidget"
                     defaultProperty: "children"
                     prototype: "QGraphicsObject"
                     Property { name: "palette"; type: "QPalette" }
                     Property { name: "font"; type: "QFont" }
                     Property { name: "layoutDirection"; type: "Qt::LayoutDirection" }
                     Property { name: "size"; type: "QSizeF" }
                     Property { name: "minimumSize"; type: "QSizeF" }
                     Property { name: "preferredSize"; type: "QSizeF" }
                     Property { name: "maximumSize"; type: "QSizeF" }
                     Property { name: "sizePolicy"; type: "QSizePolicy" }
                     Property { name: "focusPolicy"; type: "Qt::FocusPolicy" }
                     Property { name: "windowFlags"; type: "Qt::WindowFlags" }
                     Property { name: "windowTitle"; type: "string" }
                     Property { name: "geometry"; type: "QRectF" }
                     Property { name: "autoFillBackground"; type: "bool" }
                     Property { name: "layout"; type: "QGraphicsLayout"; isPointer: true }
                     Method { name: "close"; type: "bool" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeAreaSeries"
                     prototype: "QtCharts::QAreaSeries"
                     exports: [
                         "QtCharts/AreaSeries 1.0",
                         "QtCharts/AreaSeries 1.1",
                         "QtCharts/AreaSeries 1.2",
                         "QtCharts/AreaSeries 1.3",
                         "QtCharts/AreaSeries 1.4",
                         "QtCharts/AreaSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4, 4]
                     Property { name: "upperSeries"; type: "DeclarativeLineSeries"; isPointer: true }
                     Property { name: "lowerSeries"; type: "DeclarativeLineSeries"; isPointer: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "brushFilename"; revision: 4; type: "string" }
                     Property { name: "brush"; revision: 4; type: "QBrush" }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal { name: "brushChanged"; revision: 4 }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 4
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeAxes"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/DeclarativeAxes 1.0",
                         "QtCharts/DeclarativeAxes 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; type: "QAbstractAxis"; isPointer: true }
                     Signal {
                         name: "axisXChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QBarSeries"
                     exports: [
                         "QtCharts/BarSeries 1.0",
                         "QtCharts/BarSeries 1.1",
                         "QtCharts/BarSeries 1.2",
                         "QtCharts/BarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBarSet"
                     prototype: "QtCharts::QBarSet"
                     exports: [
                         "QtCharts/BarSet 1.0",
                         "QtCharts/BarSet 1.1",
                         "QtCharts/BarSet 1.4",
                         "QtCharts/BarSet 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 2, 2]
                     Property { name: "values"; type: "QVariantList" }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "brushFilename"; revision: 2; type: "string" }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 2
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "at"
                         type: "double"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBoxPlotSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QBoxPlotSeries"
                     exports: [
                         "QtCharts/BoxPlotSeries 1.3",
                         "QtCharts/BoxPlotSeries 1.4",
                         "QtCharts/BoxPlotSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 1]
                     Property { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "brushFilename"; revision: 1; type: "string" }
                     Signal {
                         name: "axisXChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "clicked"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "boxset"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 1
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "onHovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onPressed"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onReleased"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "onDoubleClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "box"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBoxSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "box"; type: "DeclarativeBoxSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeBoxSet"
                     prototype: "QtCharts::QBoxSet"
                     exports: [
                         "QtCharts/BoxSet 1.3",
                         "QtCharts/BoxSet 1.4",
                         "QtCharts/BoxSet 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 1]
                     Enum {
                         name: "ValuePositions"
                         values: {
                             "LowerExtreme": 0,
                             "LowerQuartile": 1,
                             "Median": 2,
                             "UpperQuartile": 3,
                             "UpperExtreme": 4
                         }
                     }
                     Property { name: "values"; type: "QVariantList" }
                     Property { name: "label"; type: "string" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "brushFilename"; revision: 1; type: "string" }
                     Signal { name: "changedValues" }
                     Signal {
                         name: "changedValue"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 1
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "value"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "double"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "setValue"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "value"; type: "double" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeCategoryAxis"
                     defaultProperty: "axisChildren"
                     prototype: "QtCharts::QCategoryAxis"
                     exports: [
                         "QtCharts/CategoryAxis 1.1",
                         "QtCharts/CategoryAxis 2.0",
                         "QtCharts/CategoryAxis 2.1"
                     ]
                     exportMetaObjectRevisions: [0, 0, 1]
                     Enum {
                         name: "AxisLabelsPosition"
                         values: {
                             "AxisLabelsPositionCenter": 0,
                             "AxisLabelsPositionOnValue": 1
                         }
                     }
                     Property { name: "axisChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "labelsPosition"; revision: 1; type: "AxisLabelsPosition" }
                     Signal {
                         name: "labelsPositionChanged"
                         revision: 1
                         Parameter { name: "position"; type: "AxisLabelsPosition" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "categoryEndValue"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "label"; type: "string" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldLabel"; type: "string" }
                         Parameter { name: "newLabel"; type: "string" }
                     }
                     Method {
                         name: "appendAxisChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeCategoryRange"
                     prototype: "QObject"
                     exports: ["QtCharts/CategoryRange 1.1", "QtCharts/CategoryRange 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "endValue"; type: "double" }
                     Property { name: "label"; type: "string" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeChart"
                     defaultProperty: "data"
                     prototype: "QQuickPaintedItem"
                     exports: [
                         "QtCharts/ChartView 1.0",
                         "QtCharts/ChartView 1.1",
                         "QtCharts/ChartView 1.2",
                         "QtCharts/ChartView 1.3",
                         "QtCharts/ChartView 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4]
                     Enum {
                         name: "Theme"
                         values: {
                             "ChartThemeLight": 0,
                             "ChartThemeBlueCerulean": 1,
                             "ChartThemeDark": 2,
                             "ChartThemeBrownSand": 3,
                             "ChartThemeBlueNcs": 4,
                             "ChartThemeHighContrast": 5,
                             "ChartThemeBlueIcy": 6,
                             "ChartThemeQt": 7
                         }
                     }
                     Enum {
                         name: "Animation"
                         values: {
                             "NoAnimation": 0,
                             "GridAxisAnimations": 1,
                             "SeriesAnimations": 2,
                             "AllAnimations": 3
                         }
                     }
                     Enum {
                         name: "SeriesType"
                         values: {
                             "SeriesTypeLine": 0,
                             "SeriesTypeArea": 1,
                             "SeriesTypeBar": 2,
                             "SeriesTypeStackedBar": 3,
                             "SeriesTypePercentBar": 4,
                             "SeriesTypeBoxPlot": 5,
                             "SeriesTypePie": 6,
                             "SeriesTypeScatter": 7,
                             "SeriesTypeSpline": 8,
                             "SeriesTypeHorizontalBar": 9,
                             "SeriesTypeHorizontalStackedBar": 10,
                             "SeriesTypeHorizontalPercentBar": 11
                         }
                     }
                     Property { name: "theme"; type: "Theme" }
                     Property { name: "animationOptions"; type: "Animation" }
                     Property { name: "title"; type: "string" }
                     Property { name: "titleFont"; type: "QFont" }
                     Property { name: "titleColor"; type: "QColor" }
                     Property { name: "legend"; type: "QLegend"; isReadonly: true; isPointer: true }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "backgroundColor"; type: "QColor" }
                     Property { name: "dropShadowEnabled"; type: "bool" }
                     Property { name: "backgroundRoundness"; revision: 3; type: "double" }
                     Property {
                         name: "margins"
                         revision: 2
                         type: "DeclarativeMargins"
                         isReadonly: true
                         isPointer: true
                     }
                     Property { name: "plotArea"; revision: 1; type: "QRectF"; isReadonly: true }
                     Property { name: "plotAreaColor"; revision: 3; type: "QColor" }
                     Property { name: "axes"; revision: 2; type: "QAbstractAxis"; isList: true; isReadonly: true }
                     Property { name: "localizeNumbers"; revision: 4; type: "bool" }
                     Property { name: "locale"; revision: 4; type: "QLocale" }
                     Signal { name: "axisLabelsChanged" }
                     Signal {
                         name: "titleColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "dropShadowEnabledChanged"
                         Parameter { name: "enabled"; type: "bool" }
                     }
                     Signal { name: "marginsChanged"; revision: 2 }
                     Signal {
                         name: "plotAreaChanged"
                         Parameter { name: "plotArea"; type: "QRectF" }
                     }
                     Signal {
                         name: "seriesAdded"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Signal {
                         name: "seriesRemoved"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Signal { name: "plotAreaColorChanged"; revision: 3 }
                     Signal {
                         name: "backgroundRoundnessChanged"
                         revision: 3
                         Parameter { name: "diameter"; type: "double" }
                     }
                     Signal { name: "localizeNumbersChanged"; revision: 4 }
                     Signal { name: "localeChanged"; revision: 4 }
                     Method {
                         name: "series"
                         type: "QAbstractSeries*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "series"
                         type: "QAbstractSeries*"
                         Parameter { name: "seriesName"; type: "string" }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                         Parameter { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "axisY"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                         Parameter { name: "axisX"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                         Parameter { name: "name"; type: "string" }
                     }
                     Method {
                         name: "createSeries"
                         type: "QAbstractSeries*"
                         Parameter { name: "type"; type: "int" }
                     }
                     Method {
                         name: "removeSeries"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "removeAllSeries" }
                     Method {
                         name: "setAxisX"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "setAxisX"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "setAxisY"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method {
                         name: "setAxisY"
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "axisX"
                         type: "QAbstractAxis*"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "axisX"; type: "QAbstractAxis*" }
                     Method {
                         name: "axisY"
                         type: "QAbstractAxis*"
                         Parameter { name: "series"; type: "QAbstractSeries"; isPointer: true }
                     }
                     Method { name: "axisY"; type: "QAbstractAxis*" }
                     Method {
                         name: "zoom"
                         Parameter { name: "factor"; type: "double" }
                     }
                     Method {
                         name: "scrollLeft"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollRight"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollUp"
                         Parameter { name: "pixels"; type: "double" }
                     }
                     Method {
                         name: "scrollDown"
                         Parameter { name: "pixels"; type: "double" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalBarSeries"
                     exports: [
                         "QtCharts/HorizontalBarSeries 1.1",
                         "QtCharts/HorizontalBarSeries 1.2",
                         "QtCharts/HorizontalBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalPercentBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalPercentBarSeries"
                     exports: [
                         "QtCharts/HorizontalPercentBarSeries 1.1",
                         "QtCharts/HorizontalPercentBarSeries 1.2",
                         "QtCharts/HorizontalPercentBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeHorizontalStackedBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QHorizontalStackedBarSeries"
                     exports: [
                         "QtCharts/HorizontalStackedBarSeries 1.1",
                         "QtCharts/HorizontalStackedBarSeries 1.2",
                         "QtCharts/HorizontalStackedBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeLineSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QLineSeries"
                     exports: [
                         "QtCharts/LineSeries 1.0",
                         "QtCharts/LineSeries 1.1",
                         "QtCharts/LineSeries 1.2",
                         "QtCharts/LineSeries 1.3",
                         "QtCharts/LineSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 3]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "width"; revision: 1; type: "double" }
                     Property { name: "style"; revision: 1; type: "Qt::PenStyle" }
                     Property { name: "capStyle"; revision: 1; type: "Qt::PenCapStyle" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "widthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "styleChanged"
                         revision: 1
                         Parameter { name: "style"; type: "Qt::PenStyle" }
                     }
                     Signal {
                         name: "capStyleChanged"
                         revision: 1
                         Parameter { name: "capStyle"; type: "Qt::PenCapStyle" }
                     }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeMargins"
                     prototype: "QObject"
                     exports: ["QtCharts/Margins 1.1", "QtCharts/Margins 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "top"; type: "int" }
                     Property { name: "bottom"; type: "int" }
                     Property { name: "left"; type: "int" }
                     Property { name: "right"; type: "int" }
                     Signal {
                         name: "topChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "bottomChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "leftChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                     Signal {
                         name: "rightChanged"
                         Parameter { name: "top"; type: "int" }
                         Parameter { name: "bottom"; type: "int" }
                         Parameter { name: "left"; type: "int" }
                         Parameter { name: "right"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativePercentBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QPercentBarSeries"
                     exports: [
                         "QtCharts/PercentBarSeries 1.0",
                         "QtCharts/PercentBarSeries 1.1",
                         "QtCharts/PercentBarSeries 1.2",
                         "QtCharts/PercentBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativePieSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QPieSeries"
                     exports: [
                         "QtCharts/PieSeries 1.0",
                         "QtCharts/PieSeries 1.1",
                         "QtCharts/PieSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "sliceAdded"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "sliceRemoved"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleAdded"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Method {
                         name: "handleRemoved"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Method {
                         name: "at"
                         type: "QPieSlice*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "find"
                         type: "QPieSlice*"
                         Parameter { name: "label"; type: "string" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativePieSlice*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "value"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativePieSlice"
                     prototype: "QtCharts::QPieSlice"
                     exports: ["QtCharts/PieSlice 1.4", "QtCharts/PieSlice 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "brushFilename"; type: "string" }
                     Signal {
                         name: "brushFilenameChanged"
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativePolarChart"
                     defaultProperty: "data"
                     prototype: "QtCharts::DeclarativeChart"
                     exports: [
                         "QtCharts/PolarChartView 1.3",
                         "QtCharts/PolarChartView 2.0"
                     ]
                     exportMetaObjectRevisions: [1, 1]
                 }
                 Component {
                     name: "QtCharts::DeclarativeScatterSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QScatterSeries"
                     exports: [
                         "QtCharts/ScatterSeries 1.0",
                         "QtCharts/ScatterSeries 1.1",
                         "QtCharts/ScatterSeries 1.2",
                         "QtCharts/ScatterSeries 1.3",
                         "QtCharts/ScatterSeries 1.4",
                         "QtCharts/ScatterSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 4, 4]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "borderWidth"; revision: 1; type: "double" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Property { name: "brushFilename"; revision: 4; type: "string" }
                     Property { name: "brush"; revision: 4; type: "QBrush" }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "borderWidthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "brushFilenameChanged"
                         revision: 4
                         Parameter { name: "brushFilename"; type: "string" }
                     }
                     Signal { name: "brushChanged"; revision: 4 }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeSplineSeries"
                     defaultProperty: "declarativeChildren"
                     prototype: "QtCharts::QSplineSeries"
                     exports: [
                         "QtCharts/SplineSeries 1.0",
                         "QtCharts/SplineSeries 1.1",
                         "QtCharts/SplineSeries 1.2",
                         "QtCharts/SplineSeries 1.3",
                         "QtCharts/SplineSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 3, 3]
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisAngular"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisRadial"; revision: 3; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "width"; revision: 1; type: "double" }
                     Property { name: "style"; revision: 1; type: "Qt::PenStyle" }
                     Property { name: "capStyle"; revision: 1; type: "Qt::PenCapStyle" }
                     Property { name: "declarativeChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "countChanged"
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisAngularChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisRadialChanged"
                         revision: 3
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "widthChanged"
                         revision: 1
                         Parameter { name: "width"; type: "double" }
                     }
                     Signal {
                         name: "styleChanged"
                         revision: 1
                         Parameter { name: "style"; type: "Qt::PenStyle" }
                     }
                     Signal {
                         name: "capStyleChanged"
                         revision: 1
                         Parameter { name: "capStyle"; type: "Qt::PenCapStyle" }
                     }
                     Method {
                         name: "appendDeclarativeChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "handleCountChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         Parameter { name: "oldX"; type: "double" }
                         Parameter { name: "oldY"; type: "double" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "replace"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "newX"; type: "double" }
                         Parameter { name: "newY"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method {
                         name: "remove"
                         revision: 3
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "insert"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "x"; type: "double" }
                         Parameter { name: "y"; type: "double" }
                     }
                     Method { name: "clear" }
                     Method {
                         name: "at"
                         type: "QPointF"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::DeclarativeStackedBarSeries"
                     defaultProperty: "seriesChildren"
                     prototype: "QtCharts::QStackedBarSeries"
                     exports: [
                         "QtCharts/StackedBarSeries 1.0",
                         "QtCharts/StackedBarSeries 1.1",
                         "QtCharts/StackedBarSeries 1.2",
                         "QtCharts/StackedBarSeries 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 1, 2, 2]
                     Property { name: "axisX"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisY"; revision: 1; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisXTop"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "axisYRight"; revision: 2; type: "QAbstractAxis"; isPointer: true }
                     Property { name: "seriesChildren"; type: "QObject"; isList: true; isReadonly: true }
                     Signal {
                         name: "axisXChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYChanged"
                         revision: 1
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisXTopChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Signal {
                         name: "axisYRightChanged"
                         revision: 2
                         Parameter { name: "axis"; type: "QAbstractAxis"; isPointer: true }
                     }
                     Method {
                         name: "appendSeriesChildren"
                         Parameter { name: "list"; type: "QObject"; isList: true; isPointer: true }
                         Parameter { name: "element"; type: "QObject"; isPointer: true }
                     }
                     Method {
                         name: "at"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                     }
                     Method {
                         name: "append"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "insert"
                         type: "DeclarativeBarSet*"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "label"; type: "string" }
                         Parameter { name: "values"; type: "QVariantList" }
                     }
                     Method {
                         name: "remove"
                         type: "bool"
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::DeclarativeXYPoint"
                     prototype: "QObject"
                     exports: ["QtCharts/XYPoint 1.0", "QtCharts/XYPoint 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "x"; type: "double" }
                     Property { name: "y"; type: "double" }
                 }
                 Component {
                     name: "QtCharts::LegendScroller"
                     defaultProperty: "children"
                     prototype: "QtCharts::QLegend"
                 }
                 Component {
                     name: "QtCharts::QAbstractAxis"
                     prototype: "QObject"
-                    exports: ["QtCharts/AbstractAxis 1.0", "QtCharts/AbstractAxis 2.0"]
+                    exports: [
+                        "QtCharts/AbstractAxis 1.0",
+                        "QtCharts/AbstractAxis 2.0",
+                        "QtCharts/AbstractAxis 2.1"
+                    ]
                     isCreatable: false
-                    exportMetaObjectRevisions: [0, 0]
+                    exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "visible"; type: "bool" }
                     Property { name: "lineVisible"; type: "bool" }
                     Property { name: "linePen"; type: "QPen" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "labelsVisible"; type: "bool" }
                     Property { name: "labelsBrush"; type: "QBrush" }
                     Property { name: "labelsAngle"; type: "int" }
                     Property { name: "labelsFont"; type: "QFont" }
                     Property { name: "labelsColor"; type: "QColor" }
                     Property { name: "gridVisible"; type: "bool" }
                     Property { name: "gridLinePen"; type: "QPen" }
                     Property { name: "shadesVisible"; type: "bool" }
                     Property { name: "shadesColor"; type: "QColor" }
                     Property { name: "shadesBorderColor"; type: "QColor" }
                     Property { name: "shadesPen"; type: "QPen" }
                     Property { name: "shadesBrush"; type: "QBrush" }
                     Property { name: "titleText"; type: "string" }
                     Property { name: "titleBrush"; type: "QBrush" }
                     Property { name: "titleVisible"; type: "bool" }
                     Property { name: "titleFont"; type: "QFont" }
                     Property { name: "orientation"; type: "Qt::Orientation"; isReadonly: true }
                     Property { name: "alignment"; type: "Qt::Alignment"; isReadonly: true }
+                    Property { name: "reverse"; type: "bool" }
                     Signal {
                         name: "visibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "linePenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "lineVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "labelsVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "labelsBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
                     Signal {
                         name: "labelsFontChanged"
                         Parameter { name: "pen"; type: "QFont" }
                     }
                     Signal {
                         name: "labelsAngleChanged"
                         Parameter { name: "angle"; type: "int" }
                     }
                     Signal {
                         name: "gridLinePenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "gridVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "labelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "titleTextChanged"
                         Parameter { name: "title"; type: "string" }
                     }
                     Signal {
                         name: "titleBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
                     Signal {
                         name: "titleVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "titleFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "shadesVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "shadesColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "shadesBorderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "shadesPenChanged"
                         Parameter { name: "pen"; type: "QPen" }
                     }
                     Signal {
                         name: "shadesBrushChanged"
                         Parameter { name: "brush"; type: "QBrush" }
                     }
+                    Signal {
+                        name: "reverseChanged"
+                        Parameter { name: "reverse"; type: "bool" }
+                    }
                 }
                 Component {
                     name: "QtCharts::QAbstractBarSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: [
                         "QtCharts/AbstractBarSeries 1.0",
                         "QtCharts/AbstractBarSeries 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "LabelsPosition"
                         values: {
                             "LabelsCenter": 0,
                             "LabelsInsideEnd": 1,
                             "LabelsInsideBase": 2,
                             "LabelsOutsideEnd": 3
                         }
                     }
                     Property { name: "barWidth"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "labelsVisible"; type: "bool" }
                     Property { name: "labelsFormat"; type: "string" }
                     Property { name: "labelsPosition"; type: "LabelsPosition" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "barset"; type: "QBarSet"; isPointer: true }
                     }
                     Signal {
                         name: "labelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "labelsPositionChanged"
                         Parameter { name: "position"; type: "QAbstractBarSeries::LabelsPosition" }
                     }
                     Signal {
                         name: "barsetsAdded"
                         Parameter { name: "sets"; type: "QList<QBarSet*>" }
                     }
                     Signal {
                         name: "barsetsRemoved"
                         Parameter { name: "sets"; type: "QList<QBarSet*>" }
                     }
                 }
                 Component {
                     name: "QtCharts::QAbstractSeries"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/AbstractSeries 1.0",
                         "QtCharts/AbstractSeries 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "SeriesType"
                         values: {
                             "SeriesTypeLine": 0,
                             "SeriesTypeArea": 1,
                             "SeriesTypeBar": 2,
                             "SeriesTypeStackedBar": 3,
                             "SeriesTypePercentBar": 4,
                             "SeriesTypePie": 5,
                             "SeriesTypeScatter": 6,
                             "SeriesTypeSpline": 7,
                             "SeriesTypeHorizontalBar": 8,
                             "SeriesTypeHorizontalStackedBar": 9,
                             "SeriesTypeHorizontalPercentBar": 10,
                             "SeriesTypeBoxPlot": 11
                         }
                     }
                     Property { name: "name"; type: "string" }
                     Property { name: "visible"; type: "bool" }
                     Property { name: "opacity"; type: "double" }
                     Property { name: "type"; type: "SeriesType"; isReadonly: true }
                 }
                 Component {
                     name: "QtCharts::QAreaSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     Property { name: "upperSeries"; type: "QLineSeries"; isReadonly: true; isPointer: true }
                     Property { name: "lowerSeries"; type: "QLineSeries"; isReadonly: true; isPointer: true }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "pointLabelsFormat"; type: "string" }
                     Property { name: "pointLabelsVisible"; type: "bool" }
                     Property { name: "pointLabelsFont"; type: "QFont" }
                     Property { name: "pointLabelsColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "point"; type: "QPointF" }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal { name: "selected" }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "pointLabelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "pointLabelsVisibilityChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "pointLabelsFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "pointLabelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBarCategoryAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: [
                         "QtCharts/BarCategoriesAxis 1.0",
                         "QtCharts/BarCategoryAxis 1.1",
                         "QtCharts/BarCategoryAxis 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "categories"; type: "QStringList" }
                     Property { name: "min"; type: "string" }
                     Property { name: "max"; type: "string" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "string" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "string" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "string" }
                         Parameter { name: "max"; type: "string" }
                     }
                     Method { name: "clear" }
                 }
                 Component {
                     name: "QtCharts::QBarModelMapper"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/BarModelMapper 1.0",
                         "QtCharts/BarModelMapper 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component { name: "QtCharts::QBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QBarSet"
                     prototype: "QObject"
                     exports: ["QtCharts/BarSetBase 1.0", "QtCharts/BarSetBase 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "label"; type: "string" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "labelBrush"; type: "QBrush" }
                     Property { name: "labelFont"; type: "QFont" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "labelColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "labelColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "valuesAdded"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "valuesRemoved"
                         Parameter { name: "index"; type: "int" }
                         Parameter { name: "count"; type: "int" }
                     }
                     Signal {
                         name: "valueChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBoxPlotModelMapper"
                     prototype: "QObject"
                     exports: ["QtCharts/BoxPlotModelMapper 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0]
                 }
                 Component {
                     name: "QtCharts::QBoxPlotSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     Property { name: "boxOutlineVisible"; type: "bool" }
                     Property { name: "boxWidth"; type: "double" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "count"; revision: 1; type: "int"; isReadonly: true }
                     Signal {
                         name: "clicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "boxset"; type: "QBoxSet"; isPointer: true }
                     }
                     Signal { name: "boxOutlineVisibilityChanged" }
                     Signal {
                         name: "boxsetsAdded"
                         Parameter { name: "sets"; type: "QList<QBoxSet*>" }
                     }
                     Signal {
                         name: "boxsetsRemoved"
                         Parameter { name: "sets"; type: "QList<QBoxSet*>" }
                     }
                 }
                 Component {
                     name: "QtCharts::QBoxSet"
                     prototype: "QObject"
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "brush"; type: "QBrush" }
                     Signal { name: "clicked" }
                     Signal {
                         name: "hovered"
                         Parameter { name: "status"; type: "bool" }
                     }
                     Signal { name: "pressed" }
                     Signal { name: "released" }
                     Signal { name: "doubleClicked" }
                     Signal { name: "valuesChanged" }
                     Signal {
                         name: "valueChanged"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal { name: "cleared" }
                 }
                 Component {
                     name: "QtCharts::QCategoryAxis"
                     prototype: "QtCharts::QValueAxis"
                     Enum {
                         name: "AxisLabelsPosition"
                         values: {
                             "AxisLabelsPositionCenter": 0,
                             "AxisLabelsPositionOnValue": 1
                         }
                     }
                     Property { name: "startValue"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "categoriesLabels"; type: "QStringList"; isReadonly: true }
                     Property { name: "labelsPosition"; type: "AxisLabelsPosition" }
                     Signal { name: "categoriesChanged" }
                     Signal {
                         name: "labelsPositionChanged"
                         Parameter { name: "position"; type: "QCategoryAxis::AxisLabelsPosition" }
                     }
                 }
                 Component {
                     name: "QtCharts::QDateTimeAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: ["QtCharts/DateTimeAxis 1.1", "QtCharts/DateTimeAxis 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "tickCount"; type: "int" }
                     Property { name: "min"; type: "QDateTime" }
                     Property { name: "max"; type: "QDateTime" }
                     Property { name: "format"; type: "string" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "QDateTime" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "QDateTime" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "QDateTime" }
                         Parameter { name: "max"; type: "QDateTime" }
                     }
                     Signal {
                         name: "formatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "tickCountChanged"
                         Parameter { name: "tick"; type: "int" }
                     }
                 }
                 Component {
                     name: "QtCharts::QHBarModelMapper"
                     prototype: "QtCharts::QBarModelMapper"
                     exports: [
                         "QtCharts/HBarModelMapper 1.0",
                         "QtCharts/HBarModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QAbstractBarSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBarSetRow"; type: "int" }
                     Property { name: "lastBarSetRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QHPieModelMapper"
                     prototype: "QtCharts::QPieModelMapper"
                     exports: [
                         "QtCharts/HPieModelMapper 1.0",
                         "QtCharts/HPieModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QPieSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "valuesRow"; type: "int" }
                     Property { name: "labelsRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QHXYModelMapper"
                     prototype: "QtCharts::QXYModelMapper"
                     exports: [
                         "QtCharts/HXYModelMapper 1.0",
                         "QtCharts/HXYModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QXYSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "xRow"; type: "int" }
                     Property { name: "yRow"; type: "int" }
                     Property { name: "firstColumn"; type: "int" }
                     Property { name: "columnCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component { name: "QtCharts::QHorizontalBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QHorizontalPercentBarSeries"
                     prototype: "QtCharts::QAbstractBarSeries"
                 }
                 Component {
                     name: "QtCharts::QHorizontalStackedBarSeries"
                     prototype: "QtCharts::QAbstractBarSeries"
                 }
                 Component {
                     name: "QtCharts::QLegend"
                     defaultProperty: "children"
                     prototype: "QGraphicsWidget"
                     exports: ["QtCharts/Legend 1.0", "QtCharts/Legend 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "alignment"; type: "Qt::Alignment" }
                     Property { name: "backgroundVisible"; type: "bool" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "font"; type: "QFont" }
                     Property { name: "labelColor"; type: "QColor" }
                     Property { name: "reverseMarkers"; type: "bool" }
                     Signal {
                         name: "backgroundVisibleChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "fontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "labelColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "reverseMarkersChanged"
                         Parameter { name: "reverseMarkers"; type: "bool" }
                     }
                 }
                 Component { name: "QtCharts::QLineSeries"; prototype: "QtCharts::QXYSeries" }
                 Component {
                     name: "QtCharts::QLogValueAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: ["QtCharts/LogValueAxis 1.3", "QtCharts/LogValueAxis 2.0"]
                     exportMetaObjectRevisions: [0, 1]
                     Property { name: "min"; type: "double" }
                     Property { name: "max"; type: "double" }
                     Property { name: "labelFormat"; type: "string" }
                     Property { name: "base"; type: "double" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "double" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "double" }
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "labelFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "baseChanged"
                         Parameter { name: "base"; type: "double" }
                     }
                 }
                 Component { name: "QtCharts::QPercentBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QPieModelMapper"
                     prototype: "QObject"
                     exports: [
                         "QtCharts/PieModelMapper 1.0",
                         "QtCharts/PieModelMapper 2.0"
                     ]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component {
                     name: "QtCharts::QPieSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: ["QtCharts/QPieSeries 1.0", "QtCharts/QPieSeries 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "horizontalPosition"; type: "double" }
                     Property { name: "verticalPosition"; type: "double" }
                     Property { name: "size"; type: "double" }
                     Property { name: "startAngle"; type: "double" }
                     Property { name: "endAngle"; type: "double" }
                     Property { name: "count"; type: "int"; isReadonly: true }
                     Property { name: "sum"; type: "double"; isReadonly: true }
                     Property { name: "holeSize"; type: "double" }
                     Signal {
                         name: "added"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Signal {
                         name: "removed"
                         Parameter { name: "slices"; type: "QList<QPieSlice*>" }
                     }
                     Signal {
                         name: "clicked"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "slice"; type: "QPieSlice"; isPointer: true }
                     }
                 }
                 Component {
                     name: "QtCharts::QPieSlice"
                     prototype: "QObject"
                     exports: ["QtCharts/PieSlice 1.0", "QtCharts/PieSlice 2.0"]
                     exportMetaObjectRevisions: [0, 0]
                     Enum {
                         name: "LabelPosition"
                         values: {
                             "LabelOutside": 0,
                             "LabelInsideHorizontal": 1,
                             "LabelInsideTangential": 2,
                             "LabelInsideNormal": 3
                         }
                     }
                     Property { name: "label"; type: "string" }
                     Property { name: "value"; type: "double" }
                     Property { name: "labelVisible"; type: "bool" }
                     Property { name: "labelPosition"; type: "LabelPosition" }
                     Property { name: "exploded"; type: "bool" }
                     Property { name: "pen"; type: "QPen" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "borderWidth"; type: "int" }
                     Property { name: "brush"; type: "QBrush" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "labelBrush"; type: "QBrush" }
                     Property { name: "labelColor"; type: "QColor" }
                     Property { name: "labelFont"; type: "QFont" }
                     Property { name: "labelArmLengthFactor"; type: "double" }
                     Property { name: "explodeDistanceFactor"; type: "double" }
                     Property { name: "percentage"; type: "double"; isReadonly: true }
                     Property { name: "startAngle"; type: "double"; isReadonly: true }
                     Property { name: "angleSpan"; type: "double"; isReadonly: true }
                     Signal { name: "clicked" }
                     Signal {
                         name: "hovered"
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal { name: "pressed" }
                     Signal { name: "released" }
                     Signal { name: "doubleClicked" }
                 }
                 Component {
                     name: "QtCharts::QScatterSeries"
                     prototype: "QtCharts::QXYSeries"
                     Enum {
                         name: "MarkerShape"
                         values: {
                             "MarkerShapeCircle": 0,
                             "MarkerShapeRectangle": 1
                         }
                     }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "borderColor"; type: "QColor" }
                     Property { name: "markerShape"; type: "MarkerShape" }
                     Property { name: "markerSize"; type: "double" }
                     Property { name: "brush"; type: "QBrush" }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal {
                         name: "borderColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                 }
                 Component { name: "QtCharts::QSplineSeries"; prototype: "QtCharts::QLineSeries" }
                 Component { name: "QtCharts::QStackedBarSeries"; prototype: "QtCharts::QAbstractBarSeries" }
                 Component {
                     name: "QtCharts::QVBarModelMapper"
                     prototype: "QtCharts::QBarModelMapper"
                     exports: [
                         "QtCharts/VBarModelMapper 1.0",
                         "QtCharts/VBarModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QAbstractBarSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBarSetColumn"; type: "int" }
                     Property { name: "lastBarSetColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVBoxPlotModelMapper"
                     prototype: "QtCharts::QBoxPlotModelMapper"
                     exports: ["QtCharts/VBoxPlotModelMapper 2.0"]
                     exportMetaObjectRevisions: [0]
                     Property { name: "series"; type: "QBoxPlotSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "firstBoxSetColumn"; type: "int" }
                     Property { name: "lastBoxSetColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVPieModelMapper"
                     prototype: "QtCharts::QPieModelMapper"
                     exports: [
                         "QtCharts/VPieModelMapper 1.0",
                         "QtCharts/VPieModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QPieSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "valuesColumn"; type: "int" }
                     Property { name: "labelsColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QVXYModelMapper"
                     prototype: "QtCharts::QXYModelMapper"
                     exports: [
                         "QtCharts/VXYModelMapper 1.0",
                         "QtCharts/VXYModelMapper 2.0"
                     ]
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "series"; type: "QXYSeries"; isPointer: true }
                     Property { name: "model"; type: "QAbstractItemModel"; isPointer: true }
                     Property { name: "xColumn"; type: "int" }
                     Property { name: "yColumn"; type: "int" }
                     Property { name: "firstRow"; type: "int" }
                     Property { name: "rowCount"; type: "int" }
                     Signal { name: "seriesReplaced" }
                     Signal { name: "modelReplaced" }
                 }
                 Component {
                     name: "QtCharts::QValueAxis"
                     prototype: "QtCharts::QAbstractAxis"
                     exports: [
                         "QtCharts/ValueAxis 1.1",
                         "QtCharts/ValueAxis 2.0",
                         "QtCharts/ValuesAxis 1.0"
                     ]
                     exportMetaObjectRevisions: [0, 0, 0]
                     Property { name: "tickCount"; type: "int" }
                     Property { name: "min"; type: "double" }
                     Property { name: "max"; type: "double" }
                     Property { name: "labelFormat"; type: "string" }
                     Signal {
                         name: "minChanged"
                         Parameter { name: "min"; type: "double" }
                     }
                     Signal {
                         name: "maxChanged"
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "rangeChanged"
                         Parameter { name: "min"; type: "double" }
                         Parameter { name: "max"; type: "double" }
                     }
                     Signal {
                         name: "tickCountChanged"
                         Parameter { name: "tickCount"; type: "int" }
                     }
                     Signal {
                         name: "labelFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Method { name: "applyNiceNumbers" }
                 }
                 Component {
                     name: "QtCharts::QXYModelMapper"
                     prototype: "QObject"
                     exports: ["QtCharts/XYModelMapper 1.0", "QtCharts/XYModelMapper 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                 }
                 Component {
                     name: "QtCharts::QXYSeries"
                     prototype: "QtCharts::QAbstractSeries"
                     exports: ["QtCharts/XYSeries 1.0", "QtCharts/XYSeries 2.0"]
                     isCreatable: false
                     exportMetaObjectRevisions: [0, 0]
                     Property { name: "pointsVisible"; type: "bool" }
                     Property { name: "color"; type: "QColor" }
                     Property { name: "pointLabelsFormat"; type: "string" }
                     Property { name: "pointLabelsVisible"; type: "bool" }
                     Property { name: "pointLabelsFont"; type: "QFont" }
                     Property { name: "pointLabelsColor"; type: "QColor" }
                     Signal {
                         name: "clicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "hovered"
                         Parameter { name: "point"; type: "QPointF" }
                         Parameter { name: "state"; type: "bool" }
                     }
                     Signal {
                         name: "pressed"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "released"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "doubleClicked"
                         Parameter { name: "point"; type: "QPointF" }
                     }
                     Signal {
                         name: "pointReplaced"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pointRemoved"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "pointAdded"
                         Parameter { name: "index"; type: "int" }
                     }
                     Signal {
                         name: "colorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                     Signal { name: "pointsReplaced" }
                     Signal {
                         name: "pointLabelsFormatChanged"
                         Parameter { name: "format"; type: "string" }
                     }
                     Signal {
                         name: "pointLabelsVisibilityChanged"
                         Parameter { name: "visible"; type: "bool" }
                     }
                     Signal {
                         name: "pointLabelsFontChanged"
                         Parameter { name: "font"; type: "QFont" }
                     }
                     Signal {
                         name: "pointLabelsColorChanged"
                         Parameter { name: "color"; type: "QColor" }
                     }
                 }
             }

tests/auto/qcategoryaxis/tst_qcategoryaxis.cpp +19 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include <QtCharts/QCategoryAxis>
             #include <QtCharts/QLineSeries>
             class tst_QCategoryAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qcategoryaxis_data();
                 void qcategoryaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void labels_position();
                 void interval_data();
                 void interval();
+                void reverse();
             private:
                 QCategoryAxis* m_categoryaxis;
                 QLineSeries* m_series;
             };
             void tst_QCategoryAxis::initTestCase()
             {
                 qRegisterMetaType<QCategoryAxis::AxisLabelsPosition>("QCategoryAxis::AxisLabelsPosition");
             }
             void tst_QCategoryAxis::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QCategoryAxis::init()
             {
                 m_categoryaxis = new QCategoryAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_categoryaxis, m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QCategoryAxis::cleanup()
             {
                 delete m_series;
                 delete m_categoryaxis;
                 m_series = 0;
                 m_categoryaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QCategoryAxis::qcategoryaxis_data()
             {
             }
             void tst_QCategoryAxis::qcategoryaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyCompare(m_categoryaxis->max(), 0));
                 QVERIFY(qFuzzyCompare(m_categoryaxis->min(), 0));
                 QCOMPARE(m_categoryaxis->type(), QAbstractAxis::AxisTypeCategory);
                 QCOMPARE(m_categoryaxis->labelsPosition(), QCategoryAxis::AxisLabelsPositionCenter);
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyCompare(m_categoryaxis->max(), 0));
                 QVERIFY(!qFuzzyCompare(m_categoryaxis->min(), 0));
+                QCOMPARE(m_categoryaxis->isReverse(), false);
             }
             void tst_QCategoryAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << (qreal)1.0;
                 QTest::newRow("50.0") << (qreal)50.0;
                 QTest::newRow("101.0") << (qreal)101.0;
             }
             void tst_QCategoryAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMax(max);
                 QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QCategoryAxis::max()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QCategoryAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QCategoryAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QCategoryAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << (qreal)-1.0;
                 QTest::newRow("-50.0") << (qreal)-50.0;
                 QTest::newRow("-101.0") << (qreal)-101.0;
             }
             void tst_QCategoryAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMin(min);
                 QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QCategoryAxis::min()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QCategoryAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QCategoryAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QCategoryAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
                 QTest::newRow("-35.0 - 0.0") << (qreal)-35.0 << (qreal)10.0;
                 QTest::newRow("-35.0 - 0.0") << (qreal)-35.0 << (qreal)-15.0;
                 QTest::newRow("0.0 - 0.0") << (qreal)-0.1 << (qreal)0.1;
             }
             void tst_QCategoryAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setRange(min, max);
                 QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QCategoryAxis::range()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QCategoryAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QCategoryAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QCategoryAxis::interval_data()
             {
                 //
             }
             void tst_QCategoryAxis::interval()
             {
                 // append one correct interval
                 m_categoryaxis->append("first", (qreal)45);
                 QCOMPARE(m_categoryaxis->startValue("first"), (qreal)0);
                 QCOMPARE(m_categoryaxis->endValue("first"), (qreal)45);
                 // append one more correct interval
                 m_categoryaxis->append("second", (qreal)75);
                 QCOMPARE(m_categoryaxis->startValue("second"), (qreal)45);
                 QCOMPARE(m_categoryaxis->endValue("second"), (qreal)75);
                 // append one incorrect interval
                 m_categoryaxis->append("third", (qreal)15);
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->endValue(m_categoryaxis->categoriesLabels().last()), (qreal)75);
             //    QCOMPARE(intervalMax("first"), (qreal)75);
                 // append one more correct interval
                 m_categoryaxis->append("third", (qreal)100);
                 QCOMPARE(m_categoryaxis->count(), 3);
                 QCOMPARE(m_categoryaxis->startValue("third"), (qreal)75);
                 QCOMPARE(m_categoryaxis->endValue("third"), (qreal)100);
                 // remove one interval
                 m_categoryaxis->remove("first");
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->startValue("second"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_categoryaxis->endValue("second"), (qreal)75);
                 // remove one interval
                 m_categoryaxis->replaceLabel("second", "replaced");
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->startValue("replaced"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_categoryaxis->endValue("replaced"), (qreal)75);
             }
             void tst_QCategoryAxis::labels_position()
             {
                 QSignalSpy spy(m_categoryaxis,
                                SIGNAL(labelsPositionChanged(QCategoryAxis::AxisLabelsPosition)));
                 m_categoryaxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionOnValue);
                 QCOMPARE(m_categoryaxis->labelsPosition(), QCategoryAxis::AxisLabelsPositionOnValue);
                 QCOMPARE(spy.count(), 1);
             }
+            void tst_QCategoryAxis::reverse()
+            {
+                QSignalSpy spy(m_categoryaxis, SIGNAL(reverseChanged(bool)));
+                QCOMPARE(m_categoryaxis->isReverse(), false);
+                m_categoryaxis->setReverse();
+                QCOMPARE(m_categoryaxis->isReverse(), true);
+                m_chart->setAxisX(m_categoryaxis, m_series);
+                QCOMPARE(spy.count(), 1);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+                QCOMPARE(m_categoryaxis->isReverse(), true);
+            }
             QTEST_MAIN(tst_QCategoryAxis)
             #include "tst_qcategoryaxis.moc"

tests/auto/qdatetimeaxis/tst_qdatetimeaxis.cpp +18 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include <QtCharts/QDateTimeAxis>
             #include <QtCharts/QLineSeries>
             class tst_QDateTimeAxis : public QObject//: public tst_QAbstractAxis
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qdatetimeaxis_data();
                 void qdatetimeaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
+                void reverse();
             private:
                 QDateTimeAxis *m_dateTimeAxisX;
                 QDateTimeAxis *m_dateTimeAxisY;
                 QLineSeries* m_series;
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QDateTimeAxis::initTestCase()
             {
             }
             void tst_QDateTimeAxis::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QDateTimeAxis::init()
             {
                 m_dateTimeAxisX = new QDateTimeAxis();
                 m_dateTimeAxisY = new QDateTimeAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 //    tst_QAbstractAxis::init(m_datetimeaxis, m_series);
                 m_view = new QChartView;
                 m_chart = m_view->chart();
                 m_chart->addSeries(m_series);
                 m_chart->setAxisY(m_dateTimeAxisY, m_series);
                 m_chart->setAxisX(m_dateTimeAxisX, m_series);
             }
             void tst_QDateTimeAxis::cleanup()
             {
                 delete m_series;
                 delete m_dateTimeAxisX;
                 delete m_dateTimeAxisY;
                 m_series = 0;
                 m_dateTimeAxisX = 0;
                 m_dateTimeAxisY = 0;
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
                 //    tst_QAbstractAxis::cleanup();
             }
             void tst_QDateTimeAxis::qdatetimeaxis_data()
             {
             }
             void tst_QDateTimeAxis::qdatetimeaxis()
             {
                 //    qabstractaxis();
                 QCOMPARE(m_dateTimeAxisX->type(), QAbstractAxis::AxisTypeDateTime);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_dateTimeAxisX->max().toMSecsSinceEpoch() != 0);
                 QVERIFY(m_dateTimeAxisX->min().toMSecsSinceEpoch() != 0);
+                QCOMPARE(m_dateTimeAxisX->isReverse(), false);
+                QCOMPARE(m_dateTimeAxisY->isReverse(), false);
             }
             void tst_QDateTimeAxis::max_raw_data()
             {
                 QTest::addColumn<QDateTime>("max");
                 QTest::addColumn<bool>("valid");
                 QDateTime dateTime;
                 dateTime.setDate(QDate(2012, 7, 19));
                 QTest::newRow("19.7.2012 - Valid") << dateTime << true;
                 dateTime.setDate(QDate(2012, 17, 32));
                 QTest::newRow("32.17.2012 - Invalid") << dateTime << false;
             }
             void tst_QDateTimeAxis::max_raw()
             {
                 QFETCH(QDateTime, max);
                 QFETCH(bool, valid);
                 QSignalSpy spy0(m_dateTimeAxisX, SIGNAL(maxChanged(QDateTime)));
                 QSignalSpy spy1(m_dateTimeAxisX, SIGNAL(minChanged(QDateTime)));
                 QSignalSpy spy2(m_dateTimeAxisX, SIGNAL(rangeChanged(QDateTime,QDateTime)));
                 m_dateTimeAxisX->setMax(max);
                 if (valid) {
                     QVERIFY2(m_dateTimeAxisX->max() == max, "Not equal");
                     QCOMPARE(spy0.count(), 1);
                     QCOMPARE(spy1.count(), 0);
                     QCOMPARE(spy2.count(), 1);
                 } else {
                     QVERIFY2(m_dateTimeAxisX->max() != max, "Date is invalid and should not be set");
                     QCOMPARE(spy0.count(), 0);
                     QCOMPARE(spy1.count(), 0);
                     QCOMPARE(spy2.count(), 0);
                 }
             }
             void tst_QDateTimeAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QDateTimeAxis::max()
             {
             //    m_chart->setAxisX(m_dateTimeAxisX, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QDateTimeAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QDateTimeAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QDateTimeAxis::min_raw_data()
             {
                 QTest::addColumn<QDateTime>("min");
                 QTest::addColumn<bool>("valid");
                 QDateTime dateTime;
                 dateTime.setDate(QDate(1908, 1, 11));
                 QTest::newRow("11.1.1908 - Valid") << dateTime << true; // negative MSecs from Epoch
                 dateTime.setDate(QDate(2012, 17, 32));
                 QTest::newRow("32.17.2012 - Invalid") << dateTime << false;
             }
             void tst_QDateTimeAxis::min_raw()
             {
                 QFETCH(QDateTime, min);
                 QFETCH(bool, valid);
                 QSignalSpy spy0(m_dateTimeAxisX, SIGNAL(maxChanged(QDateTime)));
                 QSignalSpy spy1(m_dateTimeAxisX, SIGNAL(minChanged(QDateTime)));
                 QSignalSpy spy2(m_dateTimeAxisX, SIGNAL(rangeChanged(QDateTime,QDateTime)));
                 m_dateTimeAxisX->setMin(min);
                 if (valid) {
                     QVERIFY2(m_dateTimeAxisX->min() == min, "Not equal");
                     QCOMPARE(spy0.count(), 0);
                     QCOMPARE(spy1.count(), 1);
                     QCOMPARE(spy2.count(), 1);
                 } else {
                     QVERIFY2(m_dateTimeAxisX->min() != min, "Date is invalid and should not be set");
                     QCOMPARE(spy0.count(), 0);
                     QCOMPARE(spy1.count(), 0);
                     QCOMPARE(spy2.count(), 0);
                 }
             }
             void tst_QDateTimeAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QDateTimeAxis::min()
             {
             //    m_chart->setAxisX(m_dateTimeAxisX, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QDateTimeAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QDateTimeAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QDateTimeAxis::range_raw_data()
             {
                 QTest::addColumn<QDateTime>("min");
                 QTest::addColumn<bool>("minValid");
                 QTest::addColumn<QDateTime>("max");
                 QTest::addColumn<bool>("maxValid");
                 QDateTime minDateTime;
                 QDateTime maxDateTime;
                 minDateTime.setDate(QDate(1908, 1, 11));
                 maxDateTime.setDate(QDate(1958, 11, 21));
                 QTest::newRow("11.1.1908 - min valid, 21.12.1958 - max valid") << minDateTime << true << maxDateTime << true; // negative MSecs from Epoch, min < max
                 minDateTime.setDate(QDate(2012, 17, 32));
                 QTest::newRow("32.17.2012 - min invalid, 21.12.1958 - max valid") << minDateTime << false << maxDateTime << true;
                 maxDateTime.setDate(QDate(2017, 0, 1));
                 QTest::newRow("32.17.2012 - min invalid, 1.0.2017 - max invalid") << minDateTime << false << maxDateTime << false;
                 minDateTime.setDate(QDate(2012, 1, 1));
                 QTest::newRow("1.1.2012 - min valid, 1.0.2017 - max invalid") << minDateTime << true << maxDateTime << false;
                 maxDateTime.setDate(QDate(2005, 2, 5));
                 QTest::newRow("1.1.2012 - min valid, 5.2.2005 - max valid") << minDateTime << true << maxDateTime << true; // min > max
             }
             void tst_QDateTimeAxis::range_raw()
             {
                 QFETCH(QDateTime, min);
                 QFETCH(bool, minValid);
                 QFETCH(QDateTime, max);
                 QFETCH(bool, maxValid);
                 QSignalSpy spy0(m_dateTimeAxisX, SIGNAL(maxChanged(QDateTime)));
                 QSignalSpy spy1(m_dateTimeAxisX, SIGNAL(minChanged(QDateTime)));
                 QSignalSpy spy2(m_dateTimeAxisX, SIGNAL(rangeChanged(QDateTime,QDateTime)));
                 m_dateTimeAxisX->setRange(min, max);
                 if (minValid && maxValid && min < max) {
                     QCOMPARE(spy0.count(), 1);
                     QCOMPARE(spy1.count(), 1);
                     QCOMPARE(spy2.count(), 1);
                 } else {
                     QCOMPARE(spy0.count(), 0);
                     QCOMPARE(spy1.count(), 0);
                     QCOMPARE(spy2.count(), 0);
                 }
             }
             void tst_QDateTimeAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QDateTimeAxis::range()
             {
             //    m_chart->setAxisX(m_dateTimeAxisX, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QDateTimeAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QDateTimeAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
+            void tst_QDateTimeAxis::reverse()
+            {
+                QSignalSpy spy(m_dateTimeAxisX, SIGNAL(reverseChanged(bool)));
+                QCOMPARE(m_dateTimeAxisX->isReverse(), false);
+                m_dateTimeAxisX->setReverse();
+                QCOMPARE(m_dateTimeAxisX->isReverse(), true);
+                QCOMPARE(spy.count(), 1);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+                QCOMPARE(m_dateTimeAxisX->isReverse(), true);
+            }
             QTEST_MAIN(tst_QDateTimeAxis)
             #include "tst_qdatetimeaxis.moc"

tests/auto/qlogvalueaxis/tst_qlogvalueaxis.cpp +17 -2

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QLineSeries>
             #include <QtCore/QDebug>
             class tst_QLogValueAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qlogvalueaxis_data();
                 void qlogvalueaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
                 void zoom();
+                void reverse();
             private:
                 QLogValueAxis* m_logvaluesaxis;
                 QLineSeries* m_series;
             };
             void tst_QLogValueAxis::initTestCase()
             {
             }
             void tst_QLogValueAxis::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QLogValueAxis::init()
             {
                 m_logvaluesaxis = new QLogValueAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(1, 1) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_logvaluesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QLogValueAxis::cleanup()
             {
                 delete m_series;
                 delete m_logvaluesaxis;
                 m_series = 0;
                 m_logvaluesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QLogValueAxis::qlogvalueaxis_data()
             {
             }
             void tst_QLogValueAxis::qlogvalueaxis()
             {
                 qabstractaxis();
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)1);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)1);
                 QCOMPARE(m_logvaluesaxis->type(), QAbstractAxis::AxisTypeLogValue);
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)100);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)1);
+                QCOMPARE(m_logvaluesaxis->isReverse(), false);
             }
             void tst_QLogValueAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<qreal>("expected");
                 QTest::addColumn<bool>("minChanged");
                 QTest::addColumn<bool>("maxChanged");
                 QTest::newRow("-1.0") << (qreal)-1.0 << (qreal)1.0 << false << false;
                 QTest::newRow("0.0") << (qreal)0.0 << (qreal)1.0 << false << false;
                 QTest::newRow("0.5") << (qreal)0.5 << (qreal)0.5 << true << true;
                 QTest::newRow("101.0") << (qreal)101.0 << (qreal)101.0 << false << true;
             }
             void tst_QLogValueAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QFETCH(qreal, expected);
                 QFETCH(bool, minChanged);
                 QFETCH(bool, maxChanged);
                 // setting the axis in max() changes the max to value other than 1
                 // set it back to 1
                 m_logvaluesaxis->setMax((qreal)1);
                 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_logvaluesaxis->setMax(max);
                 QCOMPARE(m_logvaluesaxis->max(), expected);
                 QCOMPARE(spy0.count(), (int)maxChanged);
                 QCOMPARE(spy1.count(), (int)minChanged);
                 QCOMPARE(spy2.count(), (int)maxChanged);
             }
             void tst_QLogValueAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QLogValueAxis::max()
             {
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QLogValueAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QLogValueAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QLogValueAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("expected");
                 QTest::addColumn<bool>("minChanged");
                 QTest::addColumn<bool>("maxChanged");
                 QTest::newRow("-1.0") << (qreal)-1.0 << (qreal)1.0 << false << false;
                 QTest::newRow("0.0") << (qreal)0.0 << (qreal)1.0 << false << false;
                 QTest::newRow("0.5") << (qreal)0.5 << (qreal)0.5 << true << false;
                 QTest::newRow("101.0") << (qreal)101.0 << (qreal)101.0 << true << true;
             }
             void tst_QLogValueAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, expected);
                 QFETCH(bool, minChanged);
                 QFETCH(bool, maxChanged);
                 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_logvaluesaxis->setMin(min);
                 QCOMPARE(m_logvaluesaxis->min(), expected);
                 QCOMPARE(spy0.count(), (int)maxChanged);
                 QCOMPARE(spy1.count(), (int)minChanged);
                 QCOMPARE(spy2.count(), (int)minChanged);
             }
             void tst_QLogValueAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QLogValueAxis::min()
             {
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QLogValueAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QLogValueAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QLogValueAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<bool>("minChanged");
                 QTest::addColumn<bool>("maxChanged");
                 QTest::newRow("-1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0 << (qreal)1.0 << (qreal)1.0 << false << false;
                 QTest::newRow("1.0 - 101.0") << (qreal)1.0 << (qreal)101.0 << (qreal)1.0 << (qreal)101.0 << false << true;
                 QTest::newRow("0.1 - 1.0") << (qreal)0.1 << (qreal)1.0 << (qreal)0.1 << (qreal)1.0 << true << false;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0 << (qreal)25.0 << (qreal)75.0 << true << true;
                 QTest::newRow("10.0 - 5.0") << (qreal)10.0 << (qreal)5.0 << (qreal)1.0 << (qreal)1.0 << false << false;
             }
             void tst_QLogValueAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(bool, minChanged);
                 QFETCH(bool, maxChanged);
                 m_logvaluesaxis->setRange((qreal)1, (qreal)1);
                 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_logvaluesaxis->setRange(min, max);
                 QCOMPARE(m_logvaluesaxis->min(), expectedMin);
                 QCOMPARE(m_logvaluesaxis->max(), expectedMax);
                 QCOMPARE(spy0.count(), (int)maxChanged);
                 QCOMPARE(spy1.count(), (int)minChanged);
                 QCOMPARE(spy2.count(), (int)(minChanged || maxChanged));
             }
             void tst_QLogValueAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QLogValueAxis::range()
             {
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QLogValueAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QLogValueAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QLogValueAxis::noautoscale_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("0.1 - 101.0") << (qreal)0.1 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
             }
             void tst_QLogValueAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_logvaluesaxis->setRange(min, max);
                 QCOMPARE(m_logvaluesaxis->min(), min);
                 QCOMPARE(m_logvaluesaxis->max(), max);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
-                m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_logvaluesaxis->min(), min);
                 QCOMPARE(m_logvaluesaxis->max(), max);
             }
             void tst_QLogValueAxis::autoscale_data()
             {
             }
             void tst_QLogValueAxis::autoscale()
             {
                 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)1);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)1);
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)1);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)100);
             }
             void tst_QLogValueAxis::zoom()
             {
                 m_chart->setAxisX(m_logvaluesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_logvaluesaxis->setBase(2);
                 m_logvaluesaxis->setRange(0.5, 2);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.5);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)2.0);
                 m_chart->zoomOut();
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.25);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)4.0);
                 m_chart->zoomIn();
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.5);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)2.0);
                 m_logvaluesaxis->setRange(0.5, 1024);
                 m_chart->zoom(11.0);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)16.0);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)32.0);
                 m_logvaluesaxis->setRange(16, 64);
                 m_chart->zoom(1/3.0);
                 QCOMPARE(m_logvaluesaxis->min(), (qreal)4);
                 QCOMPARE(m_logvaluesaxis->max(), (qreal)256.0);
             }
+            void tst_QLogValueAxis::reverse()
+            {
+                QSignalSpy spy(m_logvaluesaxis, SIGNAL(reverseChanged(bool)));
+                QCOMPARE(m_logvaluesaxis->isReverse(), false);
+                m_logvaluesaxis->setReverse();
+                QCOMPARE(m_logvaluesaxis->isReverse(), true);
+                QCOMPARE(spy.count(), 1);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+                QCOMPARE(m_logvaluesaxis->isReverse(), true);
+            }
             QTEST_MAIN(tst_QLogValueAxis)
             #include "tst_qlogvalueaxis.moc"

tests/auto/qml-qtquicktest/tst_categoryaxis.qml +22 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtTest 1.0
             import QtCharts 2.1
             Rectangle {
                 width: 400
                 height: 300
                 TestCase {
                     id: tc1
                     name: "tst_qml-qtquicktest CategoryAxis"
                     when: windowShown
                     function test_minMax() {
                         compare(lineSeries1.axisX.min, 0, "AxisX min");
                         compare(lineSeries1.axisX.max, 10, "AxisX max");
                         compare(lineSeries1.axisY.min, 0, "AxisY min");
                         compare(lineSeries1.axisY.max, 10, "AxisY max");
                     }
                     function test_categories() {
                         compare(lineSeries1.axisY.startValue, 0, "AxisY start value");
                         compare(lineSeries1.axisY.count, 3, "AxisY count");
                         compare(lineSeries1.axisY.categoriesLabels[0], "label0", "AxisY categories labels");
                         compare(lineSeries1.axisY.categoriesLabels[1], "label1", "AxisY categories labels");
                         compare(lineSeries1.axisY.categoriesLabels[2], "label2", "AxisY categories labels");
                     }
                     function test_properties() {
                         compare(lineSeries1.axisY.labelsPosition, CategoryAxis.AxisLabelsPositionCenter);
+                        verify(lineSeries1.axisX.reverse == false, "AxisX reverse");
+                        verify(lineSeries1.axisY.reverse == false, "AxisY reverse");
+                        // Modify properties
+                        lineSeries1.axisX.reverse = true;
+                        verify(lineSeries1.axisX.reverse == true, "AxisX reverse");
+                        lineSeries1.axisX.reverse = false;
+                        verify(lineSeries1.axisX.reverse == false, "AxisX reverse");
                     }
                     function test_signals() {
                         axisLabelsPositionSpy.clear();
+                        reverseChangedSpy.clear();
                         lineSeries1.axisY.labelsPosition = CategoryAxis.AxisLabelsPositionOnValue;
-                        compare(axisLabelsPositionSpy.count, 1, "onLabelsPositionChanged")
+                        compare(axisLabelsPositionSpy.count, 1, "onLabelsPositionChanged");
+                        lineSeries1.axisX.reverse = true;
+                        compare(reverseChangedSpy.count, 1, "onReverseChanged");
+                        // restore original values
+                        lineSeries1.axisX.reverse = false;
+                        compare(reverseChangedSpy.count, 2, "onReverseChanged");
                     }
                 }
                 ChartView {
                     id: chartView
                     anchors.fill: parent
                     LineSeries {
                         id: lineSeries1
                         axisX: ValueAxis {
                             id: axisX
                             min: 0
                             max: 10
                         }
                         axisY: CategoryAxis {
                             id: axisY
                             min: 0
                             max: 10
                             startValue: 0
                             CategoryRange {
                                 label: "label0"
                                 endValue: 1
                             }
                             CategoryRange {
                                 label: "label1"
                                 endValue: 3
                             }
                             CategoryRange {
                                 label: "label2"
                                 endValue: 10
                             }
                             SignalSpy {
                                 id: axisLabelsPositionSpy
                                 target: axisY
                                 signalName: "labelsPositionChanged"
                             }
                         }
                         XYPoint { x: -1; y: -1 }
                         XYPoint { x: 0; y: 0 }
                         XYPoint { x: 5; y: 5 }
                     }
+                    SignalSpy {
+                        id: reverseChangedSpy
+                        target: axisX
+                        signalName: "reverseChanged"
+                    }
                 }
             }

tests/auto/qml-qtquicktest/tst_valueaxis.qml +18 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtTest 1.0
             import QtCharts 2.0
             Rectangle {
                 width: 400
                 height: 300
                 TestCase {
                     id: tc1
                     name: "tst_qml-qtquicktest ValueAxis"
                     when: windowShown
                     // test functions are run in alphabetical order, the name has 'a' so that it
                     // will be the first function to execute.
                     function test_a_properties() {
                         // Default properties
                         verify(axisX.min < 0, "AxisX min");
                         verify(axisX.max > 0, "AxisX max");
                         verify(axisY.min < 0, "AxisY min");
                         verify(axisY.max > 0, "AxisY max");
                         verify(axisX.tickCount == 5, "AxisX tick count");
                         verify(axisY.tickCount == 5, "AxisY tick count");
                         verify(axisX.labelFormat == "", "label format");
+                        verify(axisX.reverse == false, "AxisX reverse");
+                        verify(axisY.reverse == false, "AxisY reverse");
                         // Modify properties
                         axisX.tickCount = 3;
                         verify(axisX.tickCount == 3, "set tick count");
+                        axisX.reverse = true;
+                        verify(axisX.reverse == true, "AxisX reverse");
+                        axisX.reverse = false;
+                        verify(axisX.reverse == false, "AxisX reverse");
                     }
                     function test_functions() {
                         // Set the axis ranges to not "nice" ones...
                         var min = 0.032456456;
                         var max = 10.67845634;
                         axisX.min = min;
                         axisX.max = max;
                         axisY.min = min;
                         axisY.max = max;
                         // ...And then apply nice numbers and verify the range was changed
                         axisX.applyNiceNumbers();
                         axisY.applyNiceNumbers();
                         verify(axisX.min != min);
                         verify(axisX.max != max);
                         verify(axisY.min != min);
                         verify(axisY.max != max);
                     }
                     function test_signals() {
                         minChangedSpy.clear();
                         maxChangedSpy.clear();
+                        reverseChangedSpy.clear();
                         axisX.min = 2;
                         compare(minChangedSpy.count, 1, "onMinChanged");
                         compare(maxChangedSpy.count, 0, "onMaxChanged");
                         axisX.max = 8;
                         compare(minChangedSpy.count, 1, "onMinChanged");
                         compare(maxChangedSpy.count, 1, "onMaxChanged");
+                        axisX.reverse = true;
+                        compare(reverseChangedSpy.count, 1, "onReverseChanged");
                         // restore original values
                         axisX.min = 0;
                         axisX.max = 10;
+                        axisX.reverse = false;
                         compare(minChangedSpy.count, 2, "onMinChanged");
                         compare(maxChangedSpy.count, 2, "onMaxChanged");
+                        compare(reverseChangedSpy.count, 2, "onReverseChanged");
                     }
                 }
                 ChartView {
                     id: chartView
                     anchors.fill: parent
                     LineSeries {
                         id: lineSeries1
                         axisX: ValueAxis {
                             id: axisX
                         }
                         axisY: ValueAxis {
                             id: axisY
                         }
                         XYPoint { x: -1; y: -1 }
                         XYPoint { x: 0; y: 0 }
                         XYPoint { x: 5; y: 5 }
                     }
                     SignalSpy {
                         id: minChangedSpy
                         target: axisX
                         signalName: "minChanged"
                     }
                     SignalSpy {
                         id: maxChangedSpy
                         target: axisX
                         signalName: "maxChanged"
                     }
+                    SignalSpy {
+                        id: reverseChangedSpy
+                        target: axisX
+                        signalName: "reverseChanged"
+                    }
                 }
             }

tests/auto/qvalueaxis/tst_qvalueaxis.cpp +19 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLineSeries>
             class tst_QValueAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qvalueaxis_data();
                 void qvalueaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void applyNiceNumbers_data();
                 void applyNiceNumbers();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void ticksCount_data();
                 void ticksCount();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
+                void reverse();
             private:
                 QValueAxis* m_valuesaxis;
                 QLineSeries* m_series;
             };
             void tst_QValueAxis::initTestCase()
             {
             }
             void tst_QValueAxis::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QValueAxis::init()
             {
                 m_valuesaxis = new QValueAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_valuesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QValueAxis::cleanup()
             {
                 delete m_series;
                 delete m_valuesaxis;
                 m_series = 0;
                 m_valuesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QValueAxis::qvalueaxis_data()
             {
             }
             void tst_QValueAxis::qvalueaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyCompare(m_valuesaxis->max(), 0));
                 QVERIFY(qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValue);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyCompare(m_valuesaxis->max(), 0));
                 QVERIFY(!qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
+                QCOMPARE(m_valuesaxis->isReverse(), false);
             }
             void tst_QValueAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << (qreal)1.0;
                 QTest::newRow("50.0") << (qreal)50.0;
                 QTest::newRow("101.0") << (qreal)101.0;
             }
             void tst_QValueAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMax(max);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QValueAxis::max()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QValueAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QValueAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QValueAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << (qreal)-1.0;
                 QTest::newRow("-50.0") << (qreal)-50.0;
                 QTest::newRow("-101.0") << (qreal)-101.0;
             }
             void tst_QValueAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMin(min);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QValueAxis::min()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QValueAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QValueAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QValueAxis::applyNiceNumbers_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("ticks");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<int>("expectedTicks");
                 QTest::newRow("true 0.1 , 99.0 , 5") << true << (qreal)0.1 << (qreal)99.0 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
                 QTest::newRow("true 1 , 10.0 , 5") << true << (qreal)1.0 << (qreal)10.0 << 5 << (qreal)0.0 << (qreal)10.0 << 6;
                 QTest::newRow("true 0.1 , 6.6 , 5") << true << (qreal)0.1 << (qreal)6.6 << 5 << (qreal)0.0 << (qreal)8.0 << 5;
                 QTest::newRow("false 0.1 , 6.6 , 5") << false << (qreal)0.1 << (qreal)6.6 << 5 << (qreal)0.1 << (qreal)6.6 << 5;
                 QTest::newRow("true 0.1, 99, 5") << true << (qreal)0.1 << (qreal)99.0 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
                 QTest::newRow("true 5, 93.5 , 5") << true << (qreal)5.0 << (qreal)93.5 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
             }
             void tst_QValueAxis::applyNiceNumbers()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, ticks);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(int, expectedTicks);
                 m_valuesaxis->setRange(min, max);
                 m_valuesaxis->setTickCount(ticks);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 if(niceNumbersEnabled) m_valuesaxis->applyNiceNumbers();
                 if(!qFuzzyCompare(expectedMin, min))
                     QCOMPARE(spy1.count(), 1);
                 if(!qFuzzyCompare(expectedMax, max))
                     QCOMPARE(spy0.count(), 1);
                 if((!qFuzzyCompare(expectedMin, min)) || (!qFuzzyCompare(expectedMax, max)))
                     QCOMPARE(spy2.count(), 1);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), expectedMin), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), expectedMax), "Max not equal");
                 QCOMPARE(m_valuesaxis->tickCount(), expectedTicks);
             }
             void tst_QValueAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
             }
             void tst_QValueAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QValueAxis::range()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QValueAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QValueAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QValueAxis::ticksCount_data()
             {
                 QTest::addColumn<int>("ticksCount");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("0") << 2;
                 QTest::newRow("1") << 2;
                 QTest::newRow("2") << 2;
                 QTest::newRow("3") << 3;
                 QTest::newRow("-1") << 2;
             }
             void tst_QValueAxis::ticksCount()
             {
                 QFETCH(int, ticksCount);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setTickCount(ticksCount);
                 QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
             }
             void tst_QValueAxis::noautoscale_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
             }
             void tst_QValueAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
             }
             void tst_QValueAxis::autoscale_data()
             {
             }
             void tst_QValueAxis::autoscale()
             {
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), 0), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 0), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), -100), "Min not equal");
                 QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 100), "Max not equal");
             }
+            void tst_QValueAxis::reverse()
+            {
+                QSignalSpy spy(m_valuesaxis, SIGNAL(reverseChanged(bool)));
+                QCOMPARE(m_valuesaxis->isReverse(), false);
+                m_valuesaxis->setReverse();
+                QCOMPARE(m_valuesaxis->isReverse(), true);
+                m_chart->setAxisX(m_valuesaxis, m_series);
+                QCOMPARE(spy.count(), 1);
+                m_view->show();
+                QTest::qWaitForWindowShown(m_view);
+                QCOMPARE(m_valuesaxis->isReverse(), true);
+            }
             QTEST_MAIN(tst_QValueAxis)
             #include "tst_qvalueaxis.moc"

tests/manual/qmlchartaxis/qml/qmlchartaxis/ChartAxes.qml +6 -12

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtCharts 2.0
             ChartView {
                 id: chartView
                 title: "chart axes"
-                // TODO: Do we need a property for orientation or properties "axisX" and "axisY" on ChartView
-                // to make an axis the default axis for all series with no other axes defined...?
-            //    ValueAxis {
-            //        orientation: ValueAxis.AxisX
-            //        min: 0
-            //        max: 10
-            //    }
-            //    axisX: ValueAxis {
-            //        min: 0
-            //        max: 10
-            //    }
-                // ...Now that we don't have this implementation, the following axes won't have any affect:
                 ValueAxis {
+                    id: valueAxisX
                     min: 0
                     max: 10
                 }
                 ValueAxis {
+                    id: valueAxisY
                     min: 0
                     max: 5
                 }
                 LineSeries {
                     name: "line series"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1; y: 1 }
                     XYPoint { x: 2; y: 2 }
                     XYPoint { x: 3; y: 3 }
                     XYPoint { x: 4; y: 4 }
+                    axisX: valueAxisX
+                    axisY: valueAxisY
                 }
                 ScatterSeries {
                     name: "scatter series"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 0.5; y: 1 }
                     XYPoint { x: 1; y: 2 }
                     XYPoint { x: 1.5; y: 3 }
                     XYPoint { x: 2; y: 4 }
                     XYPoint { x: 1; y: 1 }
                     XYPoint { x: 2; y: 2 }
                     XYPoint { x: 3; y: 3 }
                     XYPoint { x: 4; y: 4 }
+                    axisX: valueAxisX
+                    axisY: valueAxisY
                 }
             //    Component.onCompleted: {
             //        // You can also set the axes dynamically
             //        chartView.setAxisX(axisX, scatter);
             //    }
             }

tests/manual/qmlchartaxis/qml/qmlchartaxis/ChartAxesRevert.qml +6 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             import QtCharts 2.0
             ChartView {
                 id: chartView
                 title: "chart axes reverted"
                 ValueAxis {
+                    id: valueAxisX
                     min: 0
                     max: 10
                 }
                 ValueAxis {
+                    id: valueAxisY
                     min: 0
                     max: 5
                 }
                 ScatterSeries {
                     name: "scatter series"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 0.5; y: 1 }
                     XYPoint { x: 1; y: 2 }
                     XYPoint { x: 1.5; y: 3 }
                     XYPoint { x: 2; y: 4 }
                     XYPoint { x: 1; y: 1 }
                     XYPoint { x: 2; y: 2 }
                     XYPoint { x: 3; y: 3 }
                     XYPoint { x: 4; y: 4 }
+                    axisX: valueAxisX
+                    axisY: valueAxisY
                 }
                 LineSeries {
                     name: "line series"
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1; y: 1 }
                     XYPoint { x: 2; y: 2 }
                     XYPoint { x: 3; y: 3 }
                     XYPoint { x: 4; y: 4 }
+                    axisX: valueAxisX
+                    axisY: valueAxisY
                 }
             }

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

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

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

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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