HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2863:15eed6371853

Add support for reversed axis when useOpenGL is true...

Andy Shaw -

r2863:15eed6371853

parent child

Context file:

r2863:15eed6371853

Collapse all files

src/charts/chartdataset.cpp +9 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <private/chartdataset_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <private/qvalueaxis_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QPieSeries>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xypolardomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             #include <private/xlogypolardomain_p.h>
             #include <private/logxypolardomain_p.h>
             #include <private/logxlogypolardomain_p.h>
             #include <private/glxyseriesdata_p.h>
             #ifndef QT_QREAL_IS_FLOAT
             #include <QtCharts/QDateTimeAxis>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
                   m_chart(chart),
                   m_glXYSeriesDataManager(new GLXYSeriesDataManager(this))
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 deleteAllSeries();
                 deleteAllAxes();
             }
             /*
              * This method adds series to chartdataset, series ownership is taken from caller.
              */
             void ChartDataSet::addSeries(QAbstractSeries *series)
             {
                 if (m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not add series. Series already on the chart.");
                     return;
                 }
                 // Ignore unsupported series added to polar chart
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) {
                     if (!(series->type() == QAbstractSeries::SeriesTypeArea
                         || series->type() == QAbstractSeries::SeriesTypeLine
                         || series->type() == QAbstractSeries::SeriesTypeScatter
                         || series->type() == QAbstractSeries::SeriesTypeSpline)) {
                         qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart.");
                         return;
                     }
                     // Disable OpenGL for series in polar charts
                     series->setUseOpenGL(false);
                     series->d_ptr->setDomain(new XYPolarDomain());
                     // Set the correct domain for upper and lower series too
                     if (series->type() == QAbstractSeries::SeriesTypeArea) {
                         foreach (QObject *child, series->children()) {
                             if (qobject_cast<QAbstractSeries *>(child)) {
                                 QAbstractSeries *childSeries = qobject_cast<QAbstractSeries *>(child);
                                 childSeries->d_ptr->setDomain(new XYPolarDomain());
                             }
                         }
                     }
                 } else {
                     series->d_ptr->setDomain(new XYDomain());
                 }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = m_chart;
                 emit seriesAdded(series);
             }
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
             void ChartDataSet::addAxis(QAbstractAxis *axis, Qt::Alignment aligment)
             {
                 if (m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
                     return;
                 }
                 axis->d_ptr->setAlignment(aligment);
                 if (!axis->alignment()) {
                     qWarning() << QObject::tr("No alignment specified !");
                     return;
                 };
                 AbstractDomain *newDomain;
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar)
                     newDomain = new XYPolarDomain();
                 else
                     newDomain = new XYDomain();
                 QSharedPointer<AbstractDomain> domain(newDomain);
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 axis->d_ptr->m_chart = m_chart;
                 m_axisList.append(axis);
                 emit axisAdded(axis);
             }
             /*
              * This method removes series form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (! m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
                     return;
                 }
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     detachAxis(series,axis);
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 // Reset domain to default
                 series->d_ptr->setDomain(new XYDomain());
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 QXYSeries *xySeries = qobject_cast<QXYSeries *>(series);
                 if (xySeries)
                     m_glXYSeriesDataManager->removeSeries(xySeries);
             }
             /*
              * This method removes axis form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (! m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
                     return;
                 }
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                   detachAxis(s,axis);
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
             }
             /*
              * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 if (!series)
                     return false;
                 QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis *> attachedAxisList = series->d_ptr->m_axes;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 if (attachedSeriesList.contains(series)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 AbstractDomain *domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
                 if (type == AbstractDomain::UndefinedDomain) return false;
                 if (domain->type() != type) {
                     AbstractDomain *old = domain;
                     domain = createDomain(type);
                     domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY());
                     // Initialize domain size to old domain size, as it won't get updated
                     // unless geometry changes.
                     domain->setSize(old->size());
                 }
                 if (!domain)
                     return false;
                 if (!domain->attachAxis(axis))
                     return false;
                 QList<AbstractDomain *> blockedDomains;
                 domain->blockRangeSignals(true);
                 blockedDomains << domain;
                 if (domain != series->d_ptr->domain()) {
                     foreach (QAbstractAxis *axis, series->d_ptr->m_axes) {
                         series->d_ptr->domain()->detachAxis(axis);
                         domain->attachAxis(axis);
                         foreach (QAbstractSeries *otherSeries, axis->d_ptr->m_series) {
                             if (otherSeries != series && otherSeries->d_ptr->domain()) {
                                 if (!otherSeries->d_ptr->domain()->rangeSignalsBlocked()) {
                                     otherSeries->d_ptr->domain()->blockRangeSignals(true);
                                     blockedDomains << otherSeries->d_ptr->domain();
                                 }
                             }
                         }
                     }
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
+                connect(axis, &QAbstractAxis::reverseChanged, this, &ChartDataSet::reverseChanged);
                 foreach (AbstractDomain *blockedDomain, blockedDomains)
                     blockedDomain->blockRangeSignals(false);
                 return true;
             }
             /*
              * This method detaches axis to series, return true if success.
              */
             bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 AbstractDomain* domain =  series->d_ptr->domain();
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (!attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis not attached to series.");
                     return false;
                 }
                 Q_ASSERT(axis->d_ptr->m_series.contains(series));
                 domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
+                disconnect(axis, &QAbstractAxis::reverseChanged, this, &ChartDataSet::reverseChanged);
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 deleteAllAxes();
                 Q_ASSERT(m_axisList.isEmpty());
                 // Select the required axis x and axis y types based on the types of the current series
                 foreach(QAbstractSeries* s, m_seriesList) {
                     typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal);
                     typeY |= s->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QAbstractAxis *axis = 0;
                 //decide what axis should be created
                 switch (type) {
                     case QAbstractAxis::AxisTypeValue:
                     axis = new QValueAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeBarCategory:
                     axis = new QBarCategoryAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategory:
                     axis = new QCategoryAxis(this);
                     break;
             #ifndef QT_QREAL_IS_FLOAT
                     case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
             #endif
                     default:
                     axis = 0;
                     break;
                 }
                 if (axis) {
                     //create one axis for all
                     addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                     qreal min = 0;
                     qreal max = 0;
                     findMinMaxForSeries(m_seriesList,orientation,min,max);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                     axis->setRange(min,max);
                 } else {
                     // Create separate axis for each series
                     foreach(QAbstractSeries *s, m_seriesList) {
                         QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
                         if(axis) {
                             addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                             attachAxis(s,axis);
                         }
                     }
                 }
             }
             void ChartDataSet::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max)
             {
                 Q_ASSERT(!series.isEmpty());
                 AbstractDomain *domain = series.first()->d_ptr->domain();
                 min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                 max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                 for (int i = 1; i< series.size(); i++) {
                     AbstractDomain *domain = series[i]->d_ptr->domain();
                     min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min);
                     max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max);
                 }
                 if (min == max) {
                     min -= 0.5;
                     max += 0.5;
                 }
             }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     s->deleteLater();
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     a->deleteLater();
                 }
                 Q_ASSERT(m_axisList.count() == 0);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomResetDomain()
             {
                 QList<AbstractDomain*> domains;
                 foreach (QAbstractSeries *s, m_seriesList) {
                     AbstractDomain *domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains << domain;
                 }
                 foreach (AbstractDomain *domain, domains)
                     domain->zoomReset();
                 foreach (AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             bool ChartDataSet::isZoomedDomain()
             {
                 foreach (QAbstractSeries *s, m_seriesList) {
                     if (s->d_ptr->domain()->isZoomed())
                         return true;
                 }
                 return false;
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 QPointF point;
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return point;
                 if (series && m_seriesList.contains(series))
                     point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
                 return point;
             }
             QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 QPointF point = m_chart->plotArea().topLeft();
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return QPoint(0, 0);
                 bool ok;
                 if (series && m_seriesList.contains(series))
                     point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok);
                 return point;
             }
             QList<QAbstractAxis *> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis *> axes)
             {
                 enum Type {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 // Assume cartesian chart type, unless chart is set
                 QChart::ChartType chartType(QChart::ChartTypeCartesian);
                 if (m_chart)
                     chartType = m_chart->chartType();
                 foreach (QAbstractAxis *axis, axes)
                 {
                     switch (axis->type()) {
                     case QAbstractAxis::AxisTypeLogValue:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= LogType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= LogType;
                         break;
                     case QAbstractAxis::AxisTypeValue:
                     case QAbstractAxis::AxisTypeBarCategory:
                     case QAbstractAxis::AxisTypeCategory:
                     case QAbstractAxis::AxisTypeDateTime:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= ValueType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= ValueType;
                         break;
                     default:
                         qWarning() << "Undefined type";
                         break;
                     }
                 }
                 if (vertical == Undefined)
                     vertical = ValueType;
                 if (horizontal == Undefined)
                     horizontal = ValueType;
                 if (vertical == ValueType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XLogYDomain;
                     if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XLogYPolarDomain;
                 }
                 if (vertical == ValueType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXLogYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXLogYPolarDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
                 switch (type)
                 {
                 case AbstractDomain::LogXLogYDomain:
                     return new LogXLogYDomain();
                 case AbstractDomain::XYDomain:
                     return new XYDomain();
                 case AbstractDomain::XLogYDomain:
                     return new XLogYDomain();
                 case AbstractDomain::LogXYDomain:
                     return new LogXYDomain();
                 case AbstractDomain::XYPolarDomain:
                     return new XYPolarDomain();
                 case AbstractDomain::XLogYPolarDomain:
                     return new XLogYPolarDomain();
                 case AbstractDomain::LogXYPolarDomain:
                     return new LogXYPolarDomain();
                 case AbstractDomain::LogXLogYPolarDomain:
                     return new LogXLogYPolarDomain();
                 default:
                     return 0;
                 }
             }
+            void ChartDataSet::reverseChanged()
+            {
+                QAbstractAxis *axis = qobject_cast<QAbstractAxis *>(sender());
+                if (axis)
+                    m_glXYSeriesDataManager->handleAxisReverseChanged(axis->d_ptr->m_series);
+            }
             #include "moc_chartdataset_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartdataset_p.h +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include <QtCharts/QAbstractSeries>
             #include <private/abstractdomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QVector>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class GLXYSeriesDataManager;
             class Q_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QChart *chart);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 QList<QAbstractSeries *> series() const;
                 void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes() const;
                 bool attachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 bool detachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 void createDefaultAxes();
                 void zoomInDomain(const QRectF &rect);
                 void zoomOutDomain(const QRectF &rect);
                 void zoomResetDomain();
                 bool isZoomedDomain();
                 void scrollDomain(qreal dx, qreal dy);
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
                 GLXYSeriesDataManager *glXYSeriesDataManager() { return m_glXYSeriesDataManager; }
             Q_SIGNALS:
                 void axisAdded(QAbstractAxis* axis);
                 void axisRemoved(QAbstractAxis* axis);
                 void seriesAdded(QAbstractSeries* series);
                 void seriesRemoved(QAbstractSeries* series);
+            public Q_SLOTS:
+                void reverseChanged();
             private:
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
                 AbstractDomain::DomainType selectDomain(QList<QAbstractAxis* > axes);
                 AbstractDomain* createDomain(AbstractDomain::DomainType type);
                 void deleteAllAxes();
                 void deleteAllSeries();
                 void findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max);
             private:
                 QList<QAbstractSeries *> m_seriesList;
                 QList<QAbstractAxis *> m_axisList;
                 QChart* m_chart;
                 GLXYSeriesDataManager *m_glXYSeriesDataManager;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTENGINE_P_H */

src/charts/glwidget.cpp +4 -1

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QT_NO_OPENGL
             #include "private/glwidget_p.h"
             #include "private/glxyseriesdata_p.h"
             #include <QtGui/QOpenGLShaderProgram>
             #include <QtGui/QOpenGLContext>
             #include <QtGui/QOpenGLBuffer>
             //#define QDEBUG_TRACE_GL_FPS
             #ifdef QDEBUG_TRACE_GL_FPS
             #  include <QElapsedTimer>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             GLWidget::GLWidget(GLXYSeriesDataManager *xyDataManager, QWidget *parent)
                 : QOpenGLWidget(parent),
                   m_program(0),
                   m_shaderAttribLoc(-1),
                   m_colorUniformLoc(-1),
                   m_minUniformLoc(-1),
                   m_deltaUniformLoc(-1),
                   m_pointSizeUniformLoc(-1),
                   m_xyDataManager(xyDataManager)
             {
                 setAttribute(Qt::WA_TranslucentBackground);
                 setAttribute(Qt::WA_AlwaysStackOnTop);
                 setAttribute(Qt::WA_TransparentForMouseEvents);
                 QSurfaceFormat surfaceFormat;
                 surfaceFormat.setDepthBufferSize(0);
                 surfaceFormat.setStencilBufferSize(0);
                 surfaceFormat.setRedBufferSize(8);
                 surfaceFormat.setGreenBufferSize(8);
                 surfaceFormat.setBlueBufferSize(8);
                 surfaceFormat.setAlphaBufferSize(8);
                 surfaceFormat.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
                 surfaceFormat.setRenderableType(QSurfaceFormat::DefaultRenderableType);
                 setFormat(surfaceFormat);
                 connect(xyDataManager, &GLXYSeriesDataManager::seriesRemoved,
                         this, &GLWidget::cleanXYSeriesResources);
             }
             GLWidget::~GLWidget()
             {
                 cleanup();
             }
             void GLWidget::cleanup()
             {
                 makeCurrent();
                 delete m_program;
                 m_program = 0;
                 foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
                     delete buffer;
                 m_seriesBufferMap.clear();
                 doneCurrent();
             }
             void GLWidget::cleanXYSeriesResources(const QXYSeries *series)
             {
                 makeCurrent();
                 if (series) {
                     delete m_seriesBufferMap.take(series);
                 } else {
                     // Null series means all series were removed
                     foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
                         delete buffer;
                     m_seriesBufferMap.clear();
                 }
                 doneCurrent();
             }
             static const char *vertexSource =
                     "attribute highp vec2 points;\n"
                     "uniform highp vec2 min;\n"
                     "uniform highp vec2 delta;\n"
                     "uniform highp float pointSize;\n"
+                    "uniform highp mat4 matrix;\n"
                     "void main() {\n"
                     "  vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
-                    "  gl_Position = vec4(normalPoint, 0, 1);\n"
+                    "  gl_Position = matrix * vec4(normalPoint, 0, 1);\n"
                     "  gl_PointSize = pointSize;\n"
                     "}";
             static const char *fragmentSource =
                     "uniform highp vec3 color;\n"
                     "void main() {\n"
                     "  gl_FragColor = vec4(color,1);\n"
                     "}\n";
             void GLWidget::initializeGL()
             {
                 connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
                 initializeOpenGLFunctions();
                 glClearColor(0, 0, 0, 0);
                 m_program = new QOpenGLShaderProgram;
                 m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
                 m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
                 m_program->bindAttributeLocation("points", 0);
                 m_program->link();
                 m_program->bind();
                 m_colorUniformLoc = m_program->uniformLocation("color");
                 m_minUniformLoc = m_program->uniformLocation("min");
                 m_deltaUniformLoc = m_program->uniformLocation("delta");
                 m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
+                m_matrixUniformLoc = m_program->uniformLocation("matrix");
                 // Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
                 // implementations this is optional and support may not be present
                 // at all. Nonetheless the below code works in all cases and makes
                 // sure there is a VAO when one is needed.
                 m_vao.create();
                 QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
                 glEnableVertexAttribArray(0);
                 glDisable(GL_DEPTH_TEST);
                 glDisable(GL_STENCIL_TEST);
             #if !defined(QT_OPENGL_ES_2)
                 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
                     // Make it possible to change point primitive size and use textures with them in
                     // the shaders. These are implicitly enabled in ES2.
                     glEnable(GL_PROGRAM_POINT_SIZE);
                 }
             #endif
                 m_program->release();
             }
             void GLWidget::paintGL()
             {
                 glClear(GL_COLOR_BUFFER_BIT);
                 QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
                 m_program->bind();
                 GLXYDataMapIterator i(m_xyDataManager->dataMap());
                 while (i.hasNext()) {
                     i.next();
                     QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
                     GLXYSeriesData *data = i.value();
                     m_program->setUniformValue(m_colorUniformLoc, data->color);
                     m_program->setUniformValue(m_minUniformLoc, data->min);
                     m_program->setUniformValue(m_deltaUniformLoc, data->delta);
+                    m_program->setUniformValue(m_matrixUniformLoc, data->matrix);
                     if (!vbo) {
                         vbo = new QOpenGLBuffer;
                         m_seriesBufferMap.insert(i.key(), vbo);
                         vbo->create();
                     }
                     vbo->bind();
                     if (data->dirty) {
                         vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
                         data->dirty = false;
                     }
                     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
                     if (data->type == QAbstractSeries::SeriesTypeLine) {
                         glLineWidth(data->width);
                         glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
                     } else { // Scatter
                         m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
                         glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
                     }
                     vbo->release();
                 }
             #ifdef QDEBUG_TRACE_GL_FPS
                 static QElapsedTimer stopWatch;
                 static int frameCount = -1;
                 if (frameCount == -1) {
                     stopWatch.start();
                     frameCount = 0;
                 }
                 frameCount++;
                 int elapsed = stopWatch.elapsed();
                 if (elapsed >= 1000) {
                     elapsed = stopWatch.restart();
                     qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
                     qDebug() << "FPS:" << fps;
                     frameCount = 0;
                 }
             #endif
                 m_program->release();
             }
             void GLWidget::resizeGL(int w, int h)
             {
                 Q_UNUSED(w)
                 Q_UNUSED(h)
             }
             QT_CHARTS_END_NAMESPACE
             #endif

src/charts/glwidget_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef GLWIDGET_H
             #define GLWIDGET_H
             #ifndef QT_NO_OPENGL
             #include <QtWidgets/QOpenGLWidget>
             #include <QtGui/QOpenGLFunctions>
             #include <QtGui/QOpenGLVertexArrayObject>
             #include <QtGui/QOpenGLBuffer>
             #include <QtCore/QHash>
             #include <QtCharts/QAbstractSeries>
             #include <QtCharts/QXYSeries>
             QT_FORWARD_DECLARE_CLASS(QOpenGLShaderProgram)
             QT_CHARTS_BEGIN_NAMESPACE
             class GLXYSeriesDataManager;
             class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions
             {
                 Q_OBJECT
             public:
                 GLWidget(GLXYSeriesDataManager *xyDataManager, QWidget *parent = 0);
                 ~GLWidget();
             public Q_SLOTS:
                 void cleanup();
                 void cleanXYSeriesResources(const QXYSeries *series);
             protected:
                 void initializeGL() Q_DECL_OVERRIDE;
                 void paintGL() Q_DECL_OVERRIDE;
                 void resizeGL(int width, int height) Q_DECL_OVERRIDE;
             private:
                 QOpenGLShaderProgram *m_program;
                 int m_shaderAttribLoc;
                 int m_colorUniformLoc;
                 int m_minUniformLoc;
                 int m_deltaUniformLoc;
                 int m_pointSizeUniformLoc;
+                int m_matrixUniformLoc;
                 QOpenGLVertexArrayObject m_vao;
                 QHash<const QAbstractSeries *, QOpenGLBuffer *> m_seriesBufferMap;
                 GLXYSeriesDataManager *m_xyDataManager;
             };
             QT_CHARTS_END_NAMESPACE
             #endif
             #endif

src/charts/xychart/glxyseriesdata.cpp +46 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "private/glxyseriesdata_p.h"
             #include "private/abstractdomain_p.h"
             #include <QtCharts/QScatterSeries>
             QT_CHARTS_BEGIN_NAMESPACE
             GLXYSeriesDataManager::GLXYSeriesDataManager(QObject *parent)
                 : QObject(parent),
                   m_mapDirty(false)
             {
             }
             GLXYSeriesDataManager::~GLXYSeriesDataManager()
             {
                 cleanup();
             }
             void GLXYSeriesDataManager::setPoints(QXYSeries *series, const AbstractDomain *domain)
             {
                 GLXYSeriesData *data = m_seriesDataMap.value(series);
                 if (!data) {
                     data = new GLXYSeriesData;
                     data->type = series->type();
                     QColor sc;
                     if (data->type == QAbstractSeries::SeriesTypeScatter) {
                         QScatterSeries *scatter = static_cast<QScatterSeries *>(series);
                         data->width = float(scatter->markerSize());
                         sc = scatter->color(); // Scatter overwrites color property
                         connect(scatter, &QScatterSeries::colorChanged, this,
                                 &GLXYSeriesDataManager::handleScatterColorChange);
                         connect(scatter, &QScatterSeries::markerSizeChanged, this,
                                 &GLXYSeriesDataManager::handleScatterMarkerSizeChange);
                     } else {
                         data->width = float(series->pen().widthF());
                         sc = series->color();
                         connect(series, &QXYSeries::penChanged, this,
                                 &GLXYSeriesDataManager::handleSeriesPenChange);
                     }
                     data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
                     connect(series, &QXYSeries::useOpenGLChanged, this,
                             &GLXYSeriesDataManager::handleSeriesOpenGLChange);
                     m_seriesDataMap.insert(series, data);
                     m_mapDirty = true;
                 }
                 QVector<float> &array = data->array;
                 bool logAxis = false;
+                bool reverseX = false;
+                bool reverseY = false;
                 foreach (QAbstractAxis* axis, series->attachedAxes()) {
                     if (axis->type() == QAbstractAxis::AxisTypeLogValue) {
                         logAxis = true;
-                        break;
+                    if (axis->isReverse()) {
+                        if (axis->orientation() == Qt::Horizontal)
+                            reverseX = true;
+                        else
+                            reverseY = true;
+                        if (reverseX && reverseY)
+                            break;
                     }
                 }
                 int count = series->count();
                 int index = 0;
                 array.resize(count * 2);
+                QMatrix4x4 matrix;
+                if (reverseX)
+                    matrix.scale(-1.0, 1.0);
+                if (reverseY)
+                    matrix.scale(1.0, -1.0);
+                data->matrix = matrix;
                 if (logAxis) {
                     // Use domain to resolve geometry points. Not as fast as shaders, but simpler that way
                     QVector<QPointF> geometryPoints = domain->calculateGeometryPoints(series->pointsVector());
                     const float height = domain->size().height();
                     if (geometryPoints.size()) {
                         for (int i = 0; i < count; i++) {
                             const QPointF &point = geometryPoints.at(i);
                             array[index++] = float(point.x());
                             array[index++] = float(height - point.y());
                         }
                     } else {
                         // If there are invalid log values, geometry points generation fails
                         for (int i = 0; i < count; i++) {
                             array[index++] = 0.0f;
                             array[index++] = 0.0f;
                         }
                     }
                     data->min = QVector2D(0, 0);
                     data->delta = QVector2D(domain->size().width() / 2.0f, domain->size().height() / 2.0f);
                 } else {
                     // Regular value axes, so we can do the math easily on shaders.
                     QVector<QPointF> seriesPoints = series->pointsVector();
                     for (int i = 0; i < count; i++) {
                         const QPointF &point = seriesPoints.at(i);
                         array[index++] = float(point.x());
                         array[index++] = float(point.y());
                     }
                     data->min = QVector2D(domain->minX(), domain->minY());
                     data->delta = QVector2D((domain->maxX() - domain->minX()) / 2.0f,
                                             (domain->maxY() - domain->minY()) / 2.0f);
                 }
                 data->dirty = true;
             }
             void GLXYSeriesDataManager::removeSeries(const QXYSeries *series)
             {
                 GLXYSeriesData *data = m_seriesDataMap.take(series);
                 if (data) {
                     disconnect(series, 0, this, 0);
                     delete data;
                     emit seriesRemoved(series);
                     m_mapDirty = true;
                 }
             }
             void GLXYSeriesDataManager::cleanup()
             {
                 foreach (GLXYSeriesData *data, m_seriesDataMap.values())
                     delete data;
                 m_seriesDataMap.clear();
                 m_mapDirty = true;
                 // Signal all series removal by using zero as parameter
                 emit seriesRemoved(0);
             }
             void GLXYSeriesDataManager::handleSeriesPenChange()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(sender());
                 if (series) {
                     GLXYSeriesData *data = m_seriesDataMap.value(series);
                     if (data) {
                         QColor sc = series->color();
                         data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
                         data->width = float(series->pen().widthF());
                         data->dirty = true;
                     }
                 }
             }
             void GLXYSeriesDataManager::handleSeriesOpenGLChange()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(sender());
                 if (!series->useOpenGL())
                     removeSeries(series);
             }
             void GLXYSeriesDataManager::handleScatterColorChange()
             {
                 QScatterSeries *series = qobject_cast<QScatterSeries *>(sender());
                 if (series) {
                     GLXYSeriesData *data = m_seriesDataMap.value(series);
                     if (data) {
                         QColor sc = series->color();
                         data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
                         data->dirty = true;
                     }
                 }
             }
             void GLXYSeriesDataManager::handleScatterMarkerSizeChange()
             {
                 QScatterSeries *series = qobject_cast<QScatterSeries *>(sender());
                 if (series) {
                     GLXYSeriesData *data = m_seriesDataMap.value(series);
                     if (data) {
                         data->width =float(series->markerSize());
                         data->dirty = true;
                     }
                 }
             }
+            void GLXYSeriesDataManager::handleAxisReverseChanged(const QList<QAbstractSeries *> &seriesList)
+            {
+                bool reverseX = false;
+                bool reverseY = false;
+                foreach (QAbstractSeries *series, seriesList) {
+                    if (QXYSeries *xyseries = qobject_cast<QXYSeries *>(series)) {
+                        GLXYSeriesData *data = m_seriesDataMap.value(xyseries);
+                        if (data) {
+                            foreach (QAbstractAxis* axis, xyseries->attachedAxes()) {
+                                if (axis->isReverse()) {
+                                    if (axis->orientation() == Qt::Horizontal)
+                                        reverseX = true;
+                                    else
+                                        reverseY = true;
+                                }
+                                if (reverseX && reverseY)
+                                    break;
+                            }
+                            QMatrix4x4 matrix;
+                            if (reverseX)
+                                matrix.scale(-1.0, 1.0);
+                            if (reverseY)
+                                matrix.scale(1.0, -1.0);
+                            data->matrix = matrix;
+                            data->dirty = true;
+                        }
+                    }
+                }
+            }
             QT_CHARTS_END_NAMESPACE

src/charts/xychart/glxyseriesdata_p.h +15 0

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef GLXYSERIESDATA_H
             #define GLXYSERIESDATA_H
             #include <QtCore/QMap>
             #include <QtCharts/QAbstractSeries>
             #include <QtCharts/QXYSeries>
             #include <QtGui/QVector3D>
             #include <QtGui/QVector2D>
+            #include <QtGui/QMatrix4x4>
             QT_CHARTS_BEGIN_NAMESPACE
             class AbstractDomain;
             struct GLXYSeriesData {
                 QVector<float> array;
                 bool dirty;
                 QVector3D color;
                 float width;
                 QAbstractSeries::SeriesType type;
                 QVector2D min;
                 QVector2D delta;
+                QMatrix4x4 matrix;
+            public:
+                GLXYSeriesData &operator=(const GLXYSeriesData &data) {
+                    array = data.array;
+                    dirty = data.dirty;
+                    color = data.color;
+                    width = data.width;
+                    type = data.type;
+                    min = data.min;
+                    delta = data.delta;
+                    matrix = data.matrix;
+                    return *this;
+                }
             };
             typedef QMap<const QXYSeries *, GLXYSeriesData *> GLXYDataMap;
             typedef QMapIterator<const QXYSeries *, GLXYSeriesData *> GLXYDataMapIterator;
             class GLXYSeriesDataManager : public QObject
             {
                 Q_OBJECT
             public:
                 GLXYSeriesDataManager(QObject *parent = 0);
                 ~GLXYSeriesDataManager();
                 void setPoints(QXYSeries *series, const AbstractDomain *domain);
                 void removeSeries(const QXYSeries *series);
                 GLXYDataMap &dataMap() { return m_seriesDataMap; }
                 // These functions are needed by qml side, so they must be inline
                 bool mapDirty() const { return m_mapDirty; }
                 void clearAllDirty() {
                     m_mapDirty = false;
                     foreach (GLXYSeriesData *data, m_seriesDataMap.values())
                         data->dirty = false;
                 }
+                void handleAxisReverseChanged(const QList<QAbstractSeries *> &seriesList);
             public Q_SLOTS:
                 void cleanup();
                 void handleSeriesPenChange();
                 void handleSeriesOpenGLChange();
                 void handleScatterColorChange();
                 void handleScatterMarkerSizeChange();
             Q_SIGNALS:
                 void seriesRemoved(const QXYSeries *series);
             private:
                 GLXYDataMap m_seriesDataMap;
                 bool m_mapDirty;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/chartsqml2/declarativerendernode.cpp +7 -17

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativerendernode.h"
             #include <QtGui/QOpenGLContext>
             #include <QtGui/QOpenGLFunctions>
             #include <QtGui/QOpenGLFramebufferObjectFormat>
             #include <QtGui/QOpenGLFramebufferObject>
             #include <QOpenGLShaderProgram>
             #include <QtGui/QOpenGLBuffer>
             //#define QDEBUG_TRACE_GL_FPS
             #ifdef QDEBUG_TRACE_GL_FPS
             #  include <QElapsedTimer>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             // This node draws the xy series data on a transparent background using OpenGL.
             // It is used as a child node of the chart node.
             DeclarativeRenderNode::DeclarativeRenderNode(QQuickWindow *window) :
                 QObject(),
                 QSGSimpleTextureNode(),
                 m_texture(0),
                 m_window(window),
                 m_textureOptions(QQuickWindow::TextureHasAlphaChannel),
                 m_textureSize(1, 1),
                 m_recreateFbo(false),
                 m_fbo(0),
                 m_program(0),
                 m_shaderAttribLoc(-1),
                 m_colorUniformLoc(-1),
                 m_minUniformLoc(-1),
                 m_deltaUniformLoc(-1),
                 m_pointSizeUniformLoc(-1),
                 m_renderNeeded(true)
             {
                 initializeOpenGLFunctions();
                 // Our texture node must have a texture, so use a default one pixel texture
                 GLuint defaultTexture = 0;
                 glGenTextures(1, &defaultTexture);
                 glBindTexture(GL_TEXTURE_2D, defaultTexture);
                 uchar buf[4] = { 0, 0, 0, 0 };
                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf);
                 QQuickWindow::CreateTextureOptions defaultTextureOptions = QQuickWindow::CreateTextureOptions(
                         QQuickWindow::TextureHasAlphaChannel | QQuickWindow::TextureOwnsGLTexture);
                 m_texture = m_window->createTextureFromId(defaultTexture, QSize(1, 1), defaultTextureOptions);
                 setTexture(m_texture);
                 setFiltering(QSGTexture::Linear);
                 setTextureCoordinatesTransform(QSGSimpleTextureNode::MirrorVertically);
             }
             DeclarativeRenderNode::~DeclarativeRenderNode()
             {
                 delete m_texture;
                 delete m_fbo;
                 delete m_program;
                 m_program = 0;
                 cleanXYSeriesResources(0);
             }
             static const char *vertexSource =
                     "attribute highp vec2 points;\n"
                     "uniform highp vec2 min;\n"
                     "uniform highp vec2 delta;\n"
                     "uniform highp float pointSize;\n"
+                    "uniform highp mat4 matrix;\n"
                     "void main() {\n"
                     "  vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
-                    "  gl_Position = vec4(normalPoint, 0, 1);\n"
+                    "  gl_Position = matrix * vec4(normalPoint, 0, 1);\n"
                     "  gl_PointSize = pointSize;\n"
                     "}";
             static const char *fragmentSource =
                     "uniform highp vec3 color;\n"
                     "void main() {\n"
                     "  gl_FragColor = vec4(color,1);\n"
                     "}\n";
             // Must be called on render thread and in context
             void DeclarativeRenderNode::initGL()
             {
                 recreateFBO();
                 m_program = new QOpenGLShaderProgram;
                 m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
                 m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
                 m_program->bindAttributeLocation("points", 0);
                 m_program->link();
                 m_program->bind();
                 m_colorUniformLoc = m_program->uniformLocation("color");
                 m_minUniformLoc = m_program->uniformLocation("min");
                 m_deltaUniformLoc = m_program->uniformLocation("delta");
                 m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
+                m_matrixUniformLoc = m_program->uniformLocation("matrix");
                 // Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
                 // implementations this is optional and support may not be present
                 // at all. Nonetheless the below code works in all cases and makes
                 // sure there is a VAO when one is needed.
                 m_vao.create();
                 QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
             #if !defined(QT_OPENGL_ES_2)
                 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
                     // Make it possible to change point primitive size and use textures with them in
                     // the shaders. These are implicitly enabled in ES2.
                     // Qt Quick doesn't change these flags, so it should be safe to just enable them
                     // at initialization.
                     glEnable(GL_PROGRAM_POINT_SIZE);
                 }
             #endif
                 m_program->release();
             }
             void DeclarativeRenderNode::recreateFBO()
             {
                 QOpenGLFramebufferObjectFormat fboFormat;
                 fboFormat.setAttachment(QOpenGLFramebufferObject::NoAttachment);
                 delete m_fbo;
                 m_fbo = new QOpenGLFramebufferObject(m_textureSize.width(),
                                                      m_textureSize.height(),
                                                      fboFormat);
                 delete m_texture;
                 m_texture = m_window->createTextureFromId(m_fbo->texture(), m_textureSize, m_textureOptions);
                 setTexture(m_texture);
                 m_recreateFbo = false;
             }
             // Must be called on render thread and in context
             void DeclarativeRenderNode::setTextureSize(const QSize &size)
             {
                 m_textureSize = size;
                 m_recreateFbo = true;
                 m_renderNeeded = true;
             }
             // Must be called on render thread while gui thread is blocked, and in context
             void DeclarativeRenderNode::setSeriesData(bool mapDirty, const GLXYDataMap &dataMap)
             {
                 if (mapDirty) {
                     // Series have changed, recreate map, but utilize old data where feasible
                     GLXYDataMap oldMap = m_xyDataMap;
                     m_xyDataMap.clear();
                     GLXYDataMapIterator i(dataMap);
                     while (i.hasNext()) {
                         i.next();
                         GLXYSeriesData *data = oldMap.take(i.key());
                         const GLXYSeriesData *newData = i.value();
                         if (!data || newData->dirty) {
                             data = new GLXYSeriesData;
-                            data->array = newData->array;
+                            *data = *newData;
-                            data->color = newData->color;
-                            data->dirty = newData->dirty;
-                            data->width = newData->width;
-                            data->type = newData->type;
-                            data->min = newData->min;
-                            data->delta = newData->delta;
                         }
                         m_xyDataMap.insert(i.key(), data);
                     }
                     // Delete remaining old data
                     i = oldMap;
                     while (i.hasNext()) {
                         i.next();
                         delete i.value();
                         cleanXYSeriesResources(i.key());
                     }
                 } else {
                     // Series have not changed, so just copy dirty data over
                     GLXYDataMapIterator i(dataMap);
                     while (i.hasNext()) {
                         i.next();
                         const GLXYSeriesData *newData = i.value();
                         if (i.value()->dirty) {
                             GLXYSeriesData *data = m_xyDataMap.value(i.key());
-                            if (data) {
+                            if (data)
-                                data->array = newData->array;
+                                *data = *newData;
-                                data->color = newData->color;
-                                data->dirty = newData->dirty;
-                                data->width = newData->width;
-                                data->type = newData->type;
-                                data->min = newData->min;
-                                data->delta = newData->delta;
                         }
                     }
                 }
                 markDirty(DirtyMaterial);
                 m_renderNeeded = true;
             }
             void DeclarativeRenderNode::renderGL()
             {
                 glClearColor(0, 0, 0, 0);
                 QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
                 m_program->bind();
                 m_fbo->bind();
                 glClear(GL_COLOR_BUFFER_BIT);
                 glEnableVertexAttribArray(0);
                 glViewport(0, 0, m_textureSize.width(), m_textureSize.height());
                 GLXYDataMapIterator i(m_xyDataMap);
                 while (i.hasNext()) {
                     i.next();
                     QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
                     GLXYSeriesData *data = i.value();
                     m_program->setUniformValue(m_colorUniformLoc, data->color);
                     m_program->setUniformValue(m_minUniformLoc, data->min);
                     m_program->setUniformValue(m_deltaUniformLoc, data->delta);
+                    m_program->setUniformValue(m_matrixUniformLoc, data->matrix);
                     if (!vbo) {
                         vbo = new QOpenGLBuffer;
                         m_seriesBufferMap.insert(i.key(), vbo);
                         vbo->create();
                     }
                     vbo->bind();
                     if (data->dirty) {
                         vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
                         data->dirty = false;
                     }
                     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
                     if (data->type == QAbstractSeries::SeriesTypeLine) {
                         glLineWidth(data->width);
                         glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
                     } else { // Scatter
                         m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
                         glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
                     }
                     vbo->release();
                 }
             #ifdef QDEBUG_TRACE_GL_FPS
                 static QElapsedTimer stopWatch;
                 static int frameCount = -1;
                 if (frameCount == -1) {
                     stopWatch.start();
                     frameCount = 0;
                 }
                 frameCount++;
                 int elapsed = stopWatch.elapsed();
                 if (elapsed >= 1000) {
                     elapsed = stopWatch.restart();
                     qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
                     qDebug() << "FPS:" << fps;
                     frameCount = 0;
                 }
             #endif
                 markDirty(DirtyMaterial);
                 m_window->resetOpenGLState();
             }
             // Must be called on render thread as response to beforeRendering signal
             void DeclarativeRenderNode::render()
             {
                 if (m_renderNeeded) {
                     if (m_xyDataMap.size()) {
                         if (!m_program)
                             initGL();
                         if (m_recreateFbo)
                             recreateFBO();
                         renderGL();
                     } else {
                         if (rect() != QRectF()) {
                             glClearColor(0, 0, 0, 0);
                             m_fbo->bind();
                             glClear(GL_COLOR_BUFFER_BIT);
                             // If last series was removed, zero out the node rect
                             setRect(QRectF());
                         }
                     }
                     m_renderNeeded = false;
                 }
             }
             void DeclarativeRenderNode::cleanXYSeriesResources(const QXYSeries *series)
             {
                 if (series) {
                     delete m_seriesBufferMap.take(series);
                     delete m_xyDataMap.take(series);
                 } else {
                     foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
                         delete buffer;
                     m_seriesBufferMap.clear();
                     foreach (GLXYSeriesData *data, m_xyDataMap.values())
                         delete data;
                     m_xyDataMap.clear();
                 }
             }
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativerendernode.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVERENDERNODE_P_H
             #define DECLARATIVERENDERNODE_P_H
             #include <QtCharts/QChartGlobal>
             #include <private/glxyseriesdata_p.h>
             #include <QtQuick/QSGSimpleTextureNode>
             #include <QtQuick/QQuickWindow>
             #include <QtGui/QOpenGLVertexArrayObject>
             #include <QtGui/QOpenGLFunctions>
             #include <QtGui/QOpenGLFramebufferObject>
             #include <QtGui/QOpenGLBuffer>
             QT_CHARTS_BEGIN_NAMESPACE
             class DeclarativeRenderNode : public QObject, public QSGSimpleTextureNode, QOpenGLFunctions
             {
                 Q_OBJECT
             public:
                 DeclarativeRenderNode(QQuickWindow *window);
                 ~DeclarativeRenderNode();
                 void initGL();
                 QSize textureSize() const { return m_textureSize; }
                 void setTextureSize(const QSize &size);
                 void setSeriesData(bool mapDirty, const GLXYDataMap &dataMap);
             public Q_SLOTS:
                 void render();
             private:
                 void renderGL();
                 void recreateFBO();
                 void cleanXYSeriesResources(const QXYSeries *series);
                 QSGTexture *m_texture;
                 QQuickWindow *m_window;
                 QQuickWindow::CreateTextureOptions m_textureOptions;
                 QSize m_textureSize;
                 bool m_recreateFbo;
                 GLXYDataMap m_xyDataMap;
                 QOpenGLFramebufferObject *m_fbo;
                 QOpenGLShaderProgram *m_program;
                 int m_shaderAttribLoc;
                 int m_colorUniformLoc;
                 int m_minUniformLoc;
                 int m_deltaUniformLoc;
                 int m_pointSizeUniformLoc;
+                int m_matrixUniformLoc;
                 QOpenGLVertexArrayObject m_vao;
                 QHash<const QAbstractSeries *, QOpenGLBuffer *> m_seriesBufferMap;
                 bool m_renderNeeded;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // DECLARATIVERENDERNODE_P_H

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