HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2826:78282651dc64

Fix issues based on android testing...

Miikka Heikkinen -

r2826:78282651dc64

parent child

Context file:

r2826:78282651dc64

Collapse all files

examples/charts/openglseries/datasource.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "datasource.h"
             #include <QtCore/QtMath>
             QT_CHARTS_USE_NAMESPACE
             DataSource::DataSource(QObject *parent) :
                 QObject(parent),
                 m_index(-1)
             {
                 generateData(0, 0, 0);
             }
             void DataSource::update(QAbstractSeries *series, int seriesIndex)
             {
                 if (series) {
                     QXYSeries *xySeries = static_cast<QXYSeries *>(series);
                     const QVector<QVector<QPointF> > &seriesData = m_data.at(seriesIndex);
                     if (seriesIndex == 0)
                         m_index++;
                     if (m_index > seriesData.count() - 1)
                         m_index = 0;
                     QVector<QPointF> points = seriesData.at(m_index);
                     // Use replace instead of clear + append, it's optimized for performance
                     xySeries->replace(points);
                 }
             }
             void DataSource::handleSceneChanged()
             {
                 m_dataUpdater.start();
             }
             void DataSource::updateAllSeries()
             {
                 static int frameCount = 0;
                 static QString labelText = QStringLiteral("FPS: %1");
                 for (int i = 0; i < m_seriesList.size(); i++)
                     update(m_seriesList[i], i);
                 frameCount++;
                 int elapsed = m_fpsTimer.elapsed();
                 if (elapsed >= 1000) {
                     elapsed = m_fpsTimer.restart();
                     qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
                     m_fpsLabel->setText(labelText.arg(QString::number(fps, 'f', 1)));
+                    m_fpsLabel->adjustSize();
                     frameCount = 0;
                 }
             }
             void DataSource::startUpdates(const QList<QXYSeries *> &seriesList, QLabel *fpsLabel)
             {
                 m_seriesList = seriesList;
                 m_fpsLabel = fpsLabel;
                 m_dataUpdater.setInterval(0);
                 m_dataUpdater.setSingleShot(true);
                 QObject::connect(&m_dataUpdater, &QTimer::timeout,
                                  this, &DataSource::updateAllSeries);
                 m_fpsTimer.start();
                 updateAllSeries();
             }
             void DataSource::generateData(int seriesCount, int rowCount, int colCount)
             {
                 // Remove previous data
                 foreach (QVector<QVector<QPointF> > seriesData, m_data) {
                     foreach (QVector<QPointF> row, seriesData)
                         row.clear();
                 }
                 m_data.clear();
                 qreal xAdjustment = 20.0 / (colCount * rowCount);
                 qreal yMultiplier = 3.0 / qreal(seriesCount);
                 // Append the new data depending on the type
                 for (int k(0); k < seriesCount; k++) {
                     QVector<QVector<QPointF> > seriesData;
                     qreal height = qreal(k) * (10.0 / qreal(seriesCount)) + 0.3;
                     for (int i(0); i < rowCount; i++) {
                         QVector<QPointF> points;
                         points.reserve(colCount);
                         for (int j(0); j < colCount; j++) {
                             qreal x(0);
                             qreal y(0);
                             // data with sin + random component
                             y = height + (yMultiplier * qSin(3.14159265358979 / 50 * j)
                                           + (yMultiplier * (qreal) rand() / (qreal) RAND_MAX));
                             // 0.000001 added to make values logaxis compatible
                             x = 0.000001 + 20.0 * (qreal(j) / qreal(colCount)) + (xAdjustment * qreal(i));
                             points.append(QPointF(x, y));
                         }
                         seriesData.append(points);
                     }
                     m_data.append(seriesData);
                 }
             }

examples/charts/openglseries/main.cpp +4 -3

             /****************************************************************************
             **
             ** 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 "datasource.h"
             #include <QtWidgets/QApplication>
             #include <QtWidgets/QMainWindow>
             #include <QtCharts/QChartView>
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtWidgets/QLabel>
             // Uncomment to use logarithmic axes instead of regular value axes
             //#define USE_LOG_AXIS
             // Uncomment to use regular series instead of OpenGL accelerated series
             //#define DONT_USE_GL_SERIES
             // Uncomment to add a simple regular series (thick line) and a matching OpenGL series (thinner line)
             // to verify the series have same visible geometry.
             //#define ADD_SIMPLE_SERIES
             QT_CHARTS_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QStringList colors;
                 colors << "red" << "blue" << "green" << "black";
                 QChart *chart = new QChart();
                 chart->legend()->hide();
             #ifdef USE_LOG_AXIS
                 QLogValueAxis *axisX = new QLogValueAxis;
                 QLogValueAxis *axisY = new QLogValueAxis;
             #else
                 QValueAxis *axisX = new QValueAxis;
                 QValueAxis *axisY = new QValueAxis;
             #endif
                 chart->addAxis(axisX, Qt::AlignBottom);
                 chart->addAxis(axisY, Qt::AlignLeft);
                 const int seriesCount = 10;
             #ifdef DONT_USE_GL_SERIES
                 const int pointCount = 100;
                 chart->setTitle("Unaccelerated Series");
             #else
                 const int pointCount = 10000;
                 chart->setTitle("OpenGL Accelerated Series");
             #endif
                 QList<QXYSeries *> seriesList;
                 for (int i = 0; i < seriesCount; i++) {
                     QXYSeries *series = 0;
                     int colorIndex = i % colors.size();
                     if (i % 2) {
                         series = new QScatterSeries;
                         QScatterSeries *scatter = static_cast<QScatterSeries *>(series);
                         scatter->setColor(QColor(colors.at(colorIndex)));
                         scatter->setMarkerSize(qreal(colorIndex + 2) / 2.0);
                         // Scatter pen doesn't have affect in OpenGL drawing, but if you disable OpenGL drawing
                         // this makes the marker border visible and gives comparable marker size to OpenGL
                         // scatter points.
                         scatter->setPen(QPen("black"));
                     } else {
                         series = new QLineSeries;
                         series->setPen(QPen(QBrush(QColor(colors.at(colorIndex))),
                                             qreal(colorIndex + 2) / 2.0));
                     }
                     seriesList.append(series);
             #ifdef DONT_USE_GL_SERIES
                     series->setUseOpenGL(false);
             #else
                     //![1]
                     series->setUseOpenGL(true);
                     //![1]
             #endif
                     chart->addSeries(series);
                     series->attachAxis(axisX);
                     series->attachAxis(axisY);
                 }
                 if (axisX->type() == QAbstractAxis::AxisTypeLogValue)
                     axisX->setRange(0.1, 20.0);
                 else
                     axisX->setRange(0, 20.0);
                 if (axisY->type() == QAbstractAxis::AxisTypeLogValue)
                     axisY->setRange(0.1, 10.0);
                 else
                     axisY->setRange(0, 10.0);
             #ifdef ADD_SIMPLE_SERIES
                 QLineSeries *simpleRasterSeries = new QLineSeries;
                 *simpleRasterSeries << QPointF(0.001, 0.001)
                              << QPointF(2.5, 8.0)
                              << QPointF(5.0, 4.0)
                              << QPointF(7.5, 9.0)
                              << QPointF(10.0, 0.001)
                              << QPointF(12.5, 2.0)
                              << QPointF(15.0, 1.0)
                              << QPointF(17.5, 6.0)
                              << QPointF(20.0, 10.0);
                 simpleRasterSeries->setUseOpenGL(false);
                 simpleRasterSeries->setPen(QPen(QBrush("magenta"), 8));
                 chart->addSeries(simpleRasterSeries);
                 simpleRasterSeries->attachAxis(axisX);
                 simpleRasterSeries->attachAxis(axisY);
                 QLineSeries *simpleGLSeries = new QLineSeries;
                 simpleGLSeries->setUseOpenGL(true);
                 simpleGLSeries->setPen(QPen(QBrush("black"), 2));
                 simpleGLSeries->replace(simpleRasterSeries->points());
                 chart->addSeries(simpleGLSeries);
                 simpleGLSeries->attachAxis(axisX);
                 simpleGLSeries->attachAxis(axisY);
             #endif
                 QChartView *chartView = new QChartView(chart);
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(600, 400);
                 window.show();
                 DataSource dataSource;
                 dataSource.generateData(seriesCount, 10, pointCount);
                 QLabel *fpsLabel = new QLabel(&window);
                 QLabel *countLabel = new QLabel(&window);
                 QString countText = QStringLiteral("Total point count: %1");
                 countLabel->setText(countText.arg(pointCount * seriesCount));
-                countLabel->resize(window.width(), countLabel->height());
+                countLabel->adjustSize();
-                fpsLabel->move(10,2);
+                fpsLabel->move(10, 2);
+                fpsLabel->adjustSize();
                 fpsLabel->raise();
                 fpsLabel->show();
-                countLabel->move(10, 14);
+                countLabel->move(10, fpsLabel->height());
                 fpsLabel->raise();
                 countLabel->show();
                 // We can get more than one changed event per frame, so do async update.
                 // This also allows the application to be responsive.
                 QObject::connect(chart->scene(), &QGraphicsScene::changed,
                                  &dataSource, &DataSource::handleSceneChanged);
                 dataSource.startUpdates(seriesList, fpsLabel);
                 return a.exec();
             }

examples/charts/qmloscilloscope/qml/qmloscilloscope/ControlPanel.qml +2 -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
             **
             ****************************************************************************/
             import QtQuick 2.1
             import QtQuick.Layouts 1.0
             ColumnLayout {
                 property alias openGLButton: openGLButton
                 spacing: 8
                 Layout.fillHeight: true
                 signal animationsEnabled(bool enabled)
                 signal seriesTypeChanged(string type)
                 signal refreshRateChanged(variant rate);
                 signal signalSourceChanged(string source, int signalCount, int sampleCount);
                 signal antialiasingEnabled(bool enabled)
                 signal openGlChanged(bool enabled)
                 Text {
                     text: "Scope"
                     font.pointSize: 18
                     color: "white"
                 }
                 MultiButton {
                     id: openGLButton
                     text: "OpenGL: "
                     items: ["false", "true"]
                     currentSelection: 0
                     onSelectionChanged: openGlChanged(currentSelection == 1);
                 }
                 MultiButton {
                     text: "Graph: "
                     items: ["line", "spline", "scatter"]
                     currentSelection: 0
                     onSelectionChanged: seriesTypeChanged(items[currentSelection]);
                 }
                 MultiButton {
                     id: signalSourceButton
                     text: "Source: "
                     items: ["sin", "linear"]
                     currentSelection: 0
                     onSelectionChanged: signalSourceChanged(
                                             selection,
 ,
                                             sampleCountButton.items[sampleCountButton.currentSelection]);
                 }
                 MultiButton {
                     id: sampleCountButton
                     text: "Samples: "
-                    items: [6, 128, 1024, 10000]
+                    items: ["6", "128", "1024", "10000"]
                     currentSelection: 2
                     onSelectionChanged: signalSourceChanged(
                                             signalSourceButton.items[signalSourceButton.currentSelection],
 ,
                                             selection);
                 }
                 MultiButton {
                     text: "Refresh rate: "
-                    items: [1, 24, 60, 100]
+                    items: ["1", "24", "60"]
                     currentSelection: 2
                     onSelectionChanged: refreshRateChanged(items[currentSelection]);
                 }
                 MultiButton {
                     text: "Animations: "
                     items: ["OFF", "ON"]
                     currentSelection: 0
                     onSelectionChanged: animationsEnabled(currentSelection == 1);
                 }
                 MultiButton {
                     text: "Antialias: "
                     items: ["OFF", "ON"]
                     currentSelection: 0
                     onSelectionChanged: antialiasingEnabled(currentSelection == 1);
                 }
             }

src/charts/chartitem.cpp +1 0

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

src/charts/chartpresenter.cpp +1 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/chartitem_p.h>
             #include <private/qchart_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/chartanimation_p.h>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAreaSeries>
             #include <private/chartaxiselement_p.h>
             #include <private/chartbackground_p.h>
             #include <private/cartesianchartlayout_p.h>
             #include <private/polarchartlayout_p.h>
             #include <private/charttitle_p.h>
             #include <QtCore/QTimer>
             #include <QtGui/QTextDocument>
+            #include <QtWidgets/QGraphicsScene>
             QT_CHARTS_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_animationDuration(ChartAnimationDuration),
                   m_animationCurve(QEasingCurve::OutQuart),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
                   m_title(0),
                   m_localizeNumbers(false)
             #ifndef QT_NO_OPENGL
                   , m_glWidget(0)
                   , m_glUseWidget(true)
             #endif
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
             #ifndef QT_NO_OPENGL
                 delete m_glWidget.data();
             #endif
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
             #ifndef QT_NO_OPENGL
                     if (!m_glWidget.isNull())
                         m_glWidget->setGeometry(m_rect.toRect());
             #endif
                     emit plotAreaChanged(m_rect);
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 series->d_ptr->setPresenter(this);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->setDataSet(m_chart->d_ptr->m_dataset);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 if (chart->animation())
                     chart->animation()->stopAndDestroyLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     QChart::AnimationOptions oldOptions = m_options;
                     m_options = options;
                     if (options.testFlag(QChart::SeriesAnimations) != oldOptions.testFlag(QChart::SeriesAnimations)) {
                         foreach (QAbstractSeries *series, m_series)
                             series->d_ptr->initializeAnimations(m_options, m_animationDuration,
                                                                 m_animationCurve);
                     }
                     if (options.testFlag(QChart::GridAxisAnimations) != oldOptions.testFlag(QChart::GridAxisAnimations)) {
                         foreach (QAbstractAxis *axis, m_axes)
                             axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     }
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setAnimationDuration(int msecs)
             {
                 if (m_animationDuration != msecs) {
                     m_animationDuration = msecs;
                     foreach (QAbstractSeries *series, m_series)
                         series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     foreach (QAbstractAxis *axis, m_axes)
                         axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setAnimationEasingCurve(const QEasingCurve &curve)
             {
                 if (m_animationCurve != curve) {
                     m_animationCurve = curve;
                     foreach (QAbstractSeries *series, m_series)
                         series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     foreach (QAbstractAxis *axis, m_axes)
                         axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
                     m_background->setBrush(QChartPrivate::defaultBrush());
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createPlotAreaBackgroundItem()
             {
                 if (!m_plotAreaBackground) {
                     if (m_chart->chartType() == QChart::ChartTypeCartesian)
                         m_plotAreaBackground = new QGraphicsRectItem(rootItem());
                     else
                         m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
                     // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
                     // antialising artifacts with axis lines for some reason.
                     m_plotAreaBackground->setPen(QPen(Qt::transparent));
                     m_plotAreaBackground->setBrush(Qt::NoBrush);
                     m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
                     m_plotAreaBackground->setVisible(false);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 animation->stop();
                 QTimer::singleShot(0, animation, SLOT(startChartAnimation()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setBackgroundRoundness(qreal diameter)
             {
                 createBackgroundItem();
                 m_background->setDiameter(diameter);
                 m_layout->invalidate();
             }
             qreal ChartPresenter::backgroundRoundness() const
             {
                 if (!m_background)
                     return 0;
                 return m_background->diameter();
             }
             void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::plotAreaBackgroundBrush() const
             {
                 if (!m_plotAreaBackground)
                     return QBrush();
                 return m_plotAreaBackground->brush();
             }
             void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::plotAreaBackgroundPen() const
             {
                 if (!m_plotAreaBackground)
                     return QPen();
                 return m_plotAreaBackground->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setDefaultTextColor(brush.color());
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return QBrush(m_title->defaultTextColor());
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setVisible(visible);
             }
             bool ChartPresenter::isPlotAreaBackgroundVisible() const
             {
                 if (!m_plotAreaBackground)
                     return false;
                 return m_plotAreaBackground->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             void ChartPresenter::setLocalizeNumbers(bool localize)
             {
                 m_localizeNumbers = localize;
                 m_layout->invalidate();
             }
             void ChartPresenter::setLocale(const QLocale &locale)
             {
                 m_locale = locale;
                 m_layout->invalidate();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
             {
                 return m_plotAreaBackground;
             }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             QRectF ChartPresenter::textBoundingRect(const QFont &font, const QString &text, qreal angle)
             {
                 static QGraphicsTextItem dummyTextItem;
                 static bool initMargin = true;
                 if (initMargin) {
                     dummyTextItem.document()->setDocumentMargin(textMargin());
                     initMargin = false;
                 }
                 dummyTextItem.setFont(font);
                 dummyTextItem.setHtml(text);
                 QRectF boundingRect = dummyTextItem.boundingRect();
                 // Take rotation into account
                 if (angle) {
                     QTransform transform;
                     transform.rotate(angle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             // boundingRect parameter returns the rotated bounding rect of the text
             QString ChartPresenter::truncatedText(const QFont &font, const QString &text, qreal angle,
                                                   qreal maxWidth, qreal maxHeight, QRectF &boundingRect)
             {
                 QString truncatedString(text);
                 boundingRect = textBoundingRect(font, truncatedString, angle);
                 if (boundingRect.width() > maxWidth || boundingRect.height() > maxHeight) {
                     // It can be assumed that almost any amount of string manipulation is faster
                     // than calculating one bounding rectangle, so first prepare a list of truncated strings
                     // to try.
                     static QRegExp truncateMatcher(QStringLiteral("&#?[0-9a-zA-Z]*;$"));
                     QVector<QString> testStrings(text.length());
                     int count(0);
                     static QLatin1Char closeTag('>');
                     static QLatin1Char openTag('<');
                     static QLatin1Char semiColon(';');
                     static QLatin1String ellipsis("...");
                     while (truncatedString.length() > 1) {
                         int chopIndex(-1);
                         int chopCount(1);
                         QChar lastChar(truncatedString.at(truncatedString.length() - 1));
                         if (lastChar == closeTag)
                             chopIndex = truncatedString.lastIndexOf(openTag);
                         else if (lastChar == semiColon)
                             chopIndex = truncateMatcher.indexIn(truncatedString, 0);
                         if (chopIndex != -1)
                             chopCount = truncatedString.length() - chopIndex;
                         truncatedString.chop(chopCount);
                         testStrings[count] = truncatedString + ellipsis;
                         count++;
                     }
                     // Binary search for best fit
                     int minIndex(0);
                     int maxIndex(count - 1);
                     int bestIndex(count);
                     QRectF checkRect;
                     while (maxIndex >= minIndex) {
                         int mid = (maxIndex + minIndex) / 2;
                         checkRect = textBoundingRect(font, testStrings.at(mid), angle);
                         if (checkRect.width() > maxWidth || checkRect.height() > maxHeight) {
                             // Checked index too large, all under this are also too large
                             minIndex = mid + 1;
                         } else {
                             // Checked index fits, all over this also fit
                             maxIndex = mid - 1;
                             bestIndex = mid;
                             boundingRect = checkRect;
                         }
                     }
                     // Default to "..." if nothing fits
                     if (bestIndex == count) {
                         boundingRect = textBoundingRect(font, ellipsis, angle);
                         truncatedString = ellipsis;
                     } else {
                         truncatedString = testStrings.at(bestIndex);
                     }
                 }
                 return truncatedString;
             }
             QString ChartPresenter::numberToString(double value, char f, int prec)
             {
                 if (m_localizeNumbers)
                     return m_locale.toString(value, f, prec);
                 else
                     return QString::number(value, f, prec);
             }
             QString ChartPresenter::numberToString(int value)
             {
                 if (m_localizeNumbers)
                     return m_locale.toString(value);
                 else
                     return QString::number(value);
             }
             void ChartPresenter::ensureGLWidget()
             {
             #ifndef QT_NO_OPENGL
                 // GLWidget pointer is wrapped in QPointer as its parent is not in our control, and therefore
                 // can potentially get deleted unexpectedly.
                 if (m_glWidget.isNull() && m_glUseWidget && m_chart->scene()) {
                     QObject *parent = m_chart->scene()->parent();
                     while (parent) {
                         QWidget *parentWidget = qobject_cast<QWidget *>(parent);
                         if (parentWidget) {
                             m_glWidget = new GLWidget(m_chart->d_ptr->m_dataset->glXYSeriesDataManager(),
                                                       parentWidget);
                             m_glWidget->setGeometry(m_rect.toRect());
                             m_glWidget->show();
                             break;
                         }
                         parent = parent->parent();
                     }
                 }
             #endif
             }
             #include "moc_chartpresenter_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartpresenter_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QChart> //because of QChart::ChartThemeId
             #include <private/glwidget_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QMargins>
             #include <QtCore/QLocale>
             #include <QtCore/QPointer>
+            #include <QtCore/QEasingCurve>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setLocalizeNumbers(bool localize);
                 inline bool localizeNumbers() const { return m_localizeNumbers; }
                 void setLocale(const QLocale &locale);
                 inline const QLocale &locale() const { return m_locale; }
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void setAnimationDuration(int msecs);
                 int animationDuration() const { return m_animationDuration; }
                 void setAnimationEasingCurve(const QEasingCurve &curve);
                 QEasingCurve animationEasingCurve() const { return m_animationCurve; }
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle,
                                              qreal maxWidth, qreal maxHeight, QRectF &boundingRect);
                 inline static qreal textMargin() { return qreal(0.5); }
                 QString numberToString(double value, char f = 'g', int prec = 6);
                 QString numberToString(int value);
                 void ensureGLWidget();
                 void glSetUseWidget(bool enable) { m_glUseWidget = enable; }
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             Q_SIGNALS:
                 void plotAreaChanged(const QRectF &plotArea);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 int m_animationDuration;
                 QEasingCurve m_animationCurve;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
                 bool m_localizeNumbers;
                 QLocale m_locale;
             #ifndef QT_NO_OPENGL
                 QPointer<GLWidget> m_glWidget;
             #endif
                 bool m_glUseWidget;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTPRESENTER_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