HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2829:473d62e0c63e

Made OpenGL series respond to scatter color and size changes...

Miikka Heikkinen -

r2829:473d62e0c63e

parent child

Context file:

r2829:473d62e0c63e

Collapse all files

src/charts/scatterchart/qscatterseries.cpp +24 -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/QScatterSeries>
             #include <private/qscatterseries_p.h>
             #include <private/scatterchartitem_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/scatteranimation_p.h>
             #include <private/qchart_p.h>
             /*!
                 \class QScatterSeries
                 \inmodule Qt Charts
                 \brief The QScatterSeries class is used for making scatter charts.
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmltype ScatterSeries
                 \instantiates QScatterSeries
                 \inqmlmodule QtCharts
                 \inherits XYSeries
                 \brief The ScatterSeries type is used for making scatter charts.
                 The following QML shows how to create a chart with two simple scatter series:
                 \snippet qmlchart/qml/qmlchart/View5.qml 1
                 \beginfloatleft
                 \image examples_qmlchart5.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \property QScatterSeries::brush
                 Brush used to draw the series.
             */
             /*!
                 \property QScatterSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QScatterSeries::brush()
             */
             /*!
                 \property QScatterSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QScatterSeries::pen()
             */
             /*!
                 \qmlproperty color ScatterSeries::borderColor
                 Border (pen) color of the series.
             */
             /*!
                 \qmlproperty real ScatterSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                 \property QScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
             */
             /*!
                 \qmlproperty MarkerShape ScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. One of ScatterSeries
                 ScatterSeries.MarkerShapeCircle or ScatterSeries.MarkerShapeRectangle.
                 The default shape is ScatterSeries.MarkerShapeCircle.
             */
             /*!
                 \property QScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \qmlproperty real ScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \qmlproperty QString ScatterSeries::brushFilename
                 The name of the file used as a brush for the series.
             */
             /*!
                 \fn void QScatterSeries::colorChanged(QColor color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
+            /*!
+                \qmlsignal ScatterSeries::onColorChanged(color color)
+                Signal is emitted when the fill (brush) color has changed to \a color.
+            */
             /*!
                 \fn void QScatterSeries::borderColorChanged(QColor color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
-                \qmlsignal ScatterSeries::borderColorChanged(color color)
+                \qmlsignal ScatterSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn QAbstractSeries::SeriesType QScatterSeries::type() const
                 Returns QAbstractSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
+            /*!
+                \fn void QScatterSeries::markerShapeChanged(MarkerShape shape)
+                Signal is emitted when the marker shape has changed to \a shape.
+            */
+            /*!
+                \qmlsignal ScatterSeries::onMarkerShapeChanged(MarkerShape shape)
+                Signal is emitted when the marker shape has changed to \a shape.
+            */
+            /*!
+                \fn void QScatterSeries::markerSizeChanged(qreal size)
+                Signal is emitted when the marker size has changed to \a size.
+            */
+            /*!
+                \qmlsignal ScatterSeries::onMarkerSizeChanged(real size)
+                Signal is emitted when the marker size has changed to \a size.
+            */
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent)
                 : QXYSeries(*new QScatterSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
             /*!
                 Sets \a pen used for drawing points' border on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QScatterSeries::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 borderColorChanged(pen.color());
                 }
             }
             /*!
                 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 QScatterSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QScatterSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = d->m_brush.color() != brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             QBrush QScatterSeries::brush() const
             {
                 Q_D(const QScatterSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QScatterSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QChartPrivate::defaultBrush())
                     b = QBrush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             QColor QScatterSeries::color() const
             {
                 return brush().color();
             }
             void QScatterSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p == QChartPrivate::defaultPen())
                     p = QPen();
                 p.setColor(color);
                 setPen(p);
             }
             QColor QScatterSeries::borderColor() const
             {
                 return pen().color();
             }
             QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
+                    emit markerShapeChanged(shape);
                 }
             }
             qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyCompare(d->m_size, size)) {
                     d->m_size = size;
                     emit d->updated();
+                    emit markerSizeChanged(size);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q)
                 : QXYSeriesPrivate(q),
                   m_shape(QScatterSeries::MarkerShapeCircle),
                   m_size(15.0)
             {
             }
             void QScatterSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,parent);
                 m_item.reset(scatter);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QScatterSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QScatterSeries);
                 const QList<QColor> colors = theme->seriesColors();
                 const QList<QGradient> gradients = theme->seriesGradients();
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen;
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
                 if (forced || QChartPrivate::defaultPen().color() == m_pointLabelsColor) {
                     QColor color = theme->labelBrush().color();
                     q->setPointLabelsColor(color);
                 }
             }
             void QScatterSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                              QEasingCurve &curve)
             {
                 ScatterChartItem *item = static_cast<ScatterChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new ScatterAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qscatterseries.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/scatterchart/qscatterseries.h +4 -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
             **
             ****************************************************************************/
             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/qxyseries.h>
             QT_CHARTS_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QT_CHARTS_EXPORT QScatterSeries : public QXYSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
-                Q_PROPERTY(MarkerShape markerShape READ markerShape WRITE setMarkerShape)
+                Q_PROPERTY(MarkerShape markerShape READ markerShape WRITE setMarkerShape NOTIFY markerShapeChanged)
-                Q_PROPERTY(qreal markerSize READ markerSize WRITE setMarkerSize)
+                Q_PROPERTY(qreal markerSize READ markerSize WRITE setMarkerSize NOTIFY markerSizeChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
                 Q_ENUMS(MarkerShape)
             public:
                 enum MarkerShape {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             public:
                 explicit QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setPen(const QPen &pen);
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(const QColor &color);
                 QColor color() const;
                 void setBorderColor(const QColor &color);
                 QColor borderColor() const;
                 MarkerShape markerShape() const;
                 void setMarkerShape(MarkerShape shape);
                 qreal markerSize() const;
                 void setMarkerSize(qreal size);
             Q_SIGNALS:
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
+                void markerShapeChanged(MarkerShape shape);
+                void markerSizeChanged(qreal size);
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
                 friend class ScatterChartItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/charts/xychart/glxyseriesdata.cpp +33 -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 "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::penChanged, this,
-                            &GLXYSeriesDataManager::handleSeriesPenChange);
                     connect(series, &QXYSeries::useOpenGLChanged, this,
                             &GLXYSeriesDataManager::handleSeriesOpenGLChange);
                     m_seriesDataMap.insert(series, data);
                     m_mapDirty = true;
                 }
                 QVector<float> &array = data->array;
                 bool logAxis = false;
                 foreach (QAbstractAxis* axis, series->attachedAxes()) {
                     if (axis->type() == QAbstractAxis::AxisTypeLogValue) {
                         logAxis = true;
                         break;
                     }
                 }
                 int count = series->count();
                 int index = 0;
                 array.resize(count * 2);
                 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;
+                    }
+                }
+            }
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef GLXYSERIESDATA_H
             #define GLXYSERIESDATA_H
             #include <QtCore/QMap>
             #include <QtCharts/QAbstractSeries>
             #include <QtCharts/QXYSeries>
             #include <QtGui/QVector3D>
             #include <QtGui/QVector2D>
             QT_CHARTS_BEGIN_NAMESPACE
             class AbstractDomain;
             struct GLXYSeriesData {
                 QVector<float> array;
                 bool dirty;
                 QVector3D color;
                 float width;
                 QAbstractSeries::SeriesType type;
                 QVector2D min;
                 QVector2D delta;
             };
             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;
                 }
             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

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