HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2241:9223452f638c

Fix deprecation errors from Qt5

Jani Honkonen -

r2241:9223452f638c

parent child

Context file:

r2241:9223452f638c

Collapse all files

demos/piechartcustomization/brushtool.cpp +15 -15

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "brushtool.h"
             #include <QPushButton>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QColorDialog>
             BrushTool::BrushTool(QString title, QWidget *parent)
                 : QWidget(parent)
             {
                 setWindowTitle(title);
                 setWindowFlags(Qt::Tool);
                 m_colorButton = new QPushButton();
                 m_styleCombo = new QComboBox();
-                m_styleCombo->addItem("Nobrush", Qt::NoBrush);
+                m_styleCombo->addItem("Nobrush", (int) Qt::NoBrush);
-                m_styleCombo->addItem("Solidpattern", Qt::SolidPattern);
+                m_styleCombo->addItem("Solidpattern", (int) Qt::SolidPattern);
-                m_styleCombo->addItem("Dense1pattern", Qt::Dense1Pattern);
+                m_styleCombo->addItem("Dense1pattern", (int) Qt::Dense1Pattern);
-                m_styleCombo->addItem("Dense2attern", Qt::Dense2Pattern);
+                m_styleCombo->addItem("Dense2attern", (int) Qt::Dense2Pattern);
-                m_styleCombo->addItem("Dense3Pattern", Qt::Dense3Pattern);
+                m_styleCombo->addItem("Dense3Pattern", (int) Qt::Dense3Pattern);
-                m_styleCombo->addItem("Dense4Pattern", Qt::Dense4Pattern);
+                m_styleCombo->addItem("Dense4Pattern", (int) Qt::Dense4Pattern);
-                m_styleCombo->addItem("Dense5Pattern", Qt::Dense5Pattern);
+                m_styleCombo->addItem("Dense5Pattern", (int) Qt::Dense5Pattern);
-                m_styleCombo->addItem("Dense6Pattern", Qt::Dense6Pattern);
+                m_styleCombo->addItem("Dense6Pattern", (int) Qt::Dense6Pattern);
-                m_styleCombo->addItem("Dense7Pattern", Qt::Dense7Pattern);
+                m_styleCombo->addItem("Dense7Pattern", (int) Qt::Dense7Pattern);
-                m_styleCombo->addItem("HorPattern", Qt::HorPattern);
+                m_styleCombo->addItem("HorPattern", (int) Qt::HorPattern);
-                m_styleCombo->addItem("VerPattern", Qt::VerPattern);
+                m_styleCombo->addItem("VerPattern", (int) Qt::VerPattern);
-                m_styleCombo->addItem("CrossPattern", Qt::CrossPattern);
+                m_styleCombo->addItem("CrossPattern", (int) Qt::CrossPattern);
-                m_styleCombo->addItem("BDiagPattern", Qt::BDiagPattern);
+                m_styleCombo->addItem("BDiagPattern", (int) Qt::BDiagPattern);
-                m_styleCombo->addItem("FDiagPattern", Qt::FDiagPattern);
+                m_styleCombo->addItem("FDiagPattern", (int) Qt::FDiagPattern);
-                m_styleCombo->addItem("DiagCrossPattern", Qt::DiagCrossPattern);
+                m_styleCombo->addItem("DiagCrossPattern", (int) Qt::DiagCrossPattern);
                 QFormLayout *layout = new QFormLayout();
                 layout->addRow("Color", m_colorButton);
                 layout->addRow("Style", m_styleCombo);
                 setLayout(layout);
                 connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                 connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle()));
             }
             void BrushTool::setBrush(QBrush brush)
             {
                 m_brush = brush;
                 m_colorButton->setText(m_brush.color().name());
                 m_styleCombo->setCurrentIndex(m_brush.style()); // index matches the enum
             }
             QBrush BrushTool::brush() const
             {
                 return m_brush;
             }
             QString BrushTool::name()
             {
                 return name(m_brush);
             }
             QString BrushTool::name(const QBrush &brush)
             {
                 return brush.color().name();
             }
             void BrushTool::showColorDialog()
             {
                 QColorDialog dialog(m_brush.color());
                 dialog.show();
                 dialog.exec();
                 m_brush.setColor(dialog.selectedColor());
                 m_colorButton->setText(m_brush.color().name());
                 emit changed();
             }
             void BrushTool::updateStyle()
             {
                 Qt::BrushStyle style = (Qt::BrushStyle) m_styleCombo->itemData(m_styleCombo->currentIndex()).toInt();
                 if (m_brush.style() != style) {
                     m_brush.setStyle(style);
                     emit changed();
                 }
             }
             #include "moc_brushtool.cpp"

examples/barmodelmapper/tablewidget.cpp +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include "customtablemodel.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QChartView>
             #include <QLineSeries>
             #include <QVXYModelMapper>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QHeaderView>
             #include <QBarCategoryAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 // create simple model for storing data
                 // user's table data model
                 //! [1]
                 CustomTableModel *model = new CustomTableModel;
                 //! [1]
                 //! [2]
                 // create table view and add model to it
                 QTableView *tableView = new QTableView;
                 tableView->setModel(model);
                 tableView->setMinimumWidth(300);
+            #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+                tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+                tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+            #else
                 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+            #endif
                 //! [2]
                 //! [3]
                 QChart *chart = new QChart;
                 chart->setAnimationOptions(QChart::AllAnimations);
                 //! [3]
                 // series 1
                 //! [4]
                 QBarSeries *series = new QBarSeries;
                 int first = 3;
                 int count = 5;
                 QVBarModelMapper *mapper = new QVBarModelMapper(this);
                 mapper->setFirstBarSetColumn(1);
                 mapper->setLastBarSetColumn(4);
                 mapper->setFirstRow(first);
                 mapper->setRowCount(count);
                 mapper->setSeries(series);
                 mapper->setModel(model);
                 chart->addSeries(series);
                 //! [4]
                 //! [5]
                 // for storing color hex from the series
                 QString seriesColorHex = "#000000";
                 // get the color of the series and use it for showing the mapped area
                 QList<QBarSet *> barsets = series->barSets();
                 for (int i = 0; i < barsets.count(); i++) {
                     seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                     model->addMapping(seriesColorHex, QRect(1 + i, first, 1, barsets.at(i)->count()));
                 }
                 //! [5]
                 //! [6]
                 QStringList categories;
                 categories << "April" << "May" << "June" << "July" << "August";
                 QBarCategoryAxis *axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);
                 //! [6]
                 //! [7]
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setMinimumSize(640, 480);
                 //! [7]
                 //! [8]
                 // create main layout
                 QGridLayout *mainLayout = new QGridLayout;
                 mainLayout->addWidget(tableView, 1, 0);
                 mainLayout->addWidget(chartView, 1, 1);
                 mainLayout->setColumnStretch(1, 1);
                 mainLayout->setColumnStretch(0, 0);
                 setLayout(mainLayout);
                 //! [8]
             }

examples/modeldata/tablewidget.cpp +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include "customtablemodel.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QChartView>
             #include <QLineSeries>
             #include <QVXYModelMapper>
             #include <QHeaderView>
             QTCOMMERCIALCHART_USE_NAMESPACE
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 // create simple model for storing data
                 // user's table data model
                 //! [1]
                 CustomTableModel *model = new CustomTableModel;
                 //! [1]
                 //! [2]
                 // create table view and add model to it
                 QTableView *tableView = new QTableView;
                 tableView->setModel(model);
+            #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+                tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+                tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+            #else
                 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+            #endif
                 //! [2]
                 //! [3]
                 QChart *chart = new QChart;
                 chart->setAnimationOptions(QChart::AllAnimations);
                 //! [3]
                 // series 1
                 //! [4]
                 QLineSeries *series = new QLineSeries;
                 series->setName("Line 1");
                 QVXYModelMapper *mapper = new QVXYModelMapper(this);
                 mapper->setXColumn(0);
                 mapper->setYColumn(1);
                 mapper->setSeries(series);
                 mapper->setModel(model);
                 chart->addSeries(series);
                 //! [4]
                 //! [5]
                 // for storing color hex from the series
                 QString seriesColorHex = "#000000";
                 // get the color of the series and use it for showing the mapped area
                 seriesColorHex = "#" + QString::number(series->pen().color().rgb(), 16).right(6).toUpper();
                 model->addMapping(seriesColorHex, QRect(0, 0, 2, model->rowCount()));
                 //! [5]
                 // series 2
                 //! [6]
                 series = new QLineSeries;
                 series->setName("Line 2");
                 mapper = new QVXYModelMapper(this);
                 mapper->setXColumn(2);
                 mapper->setYColumn(3);
                 mapper->setSeries(series);
                 mapper->setModel(model);
                 chart->addSeries(series);
                 //! [6]
                 //! [7]
                 // get the color of the series and use it for showing the mapped area
                 seriesColorHex = "#" + QString::number(series->pen().color().rgb(), 16).right(6).toUpper();
                 model->addMapping(seriesColorHex, QRect(2, 0, 2, model->rowCount()));
                 //! [7]
                 //! [8]
                 chart->createDefaultAxes();
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setMinimumSize(640, 480);
                 //! [8]
                 //! [9]
                 // create main layout
                 QGridLayout *mainLayout = new QGridLayout;
                 mainLayout->addWidget(tableView, 1, 0);
                 mainLayout->addWidget(chartView, 1, 1);
                 mainLayout->setColumnStretch(1, 1);
                 mainLayout->setColumnStretch(0, 0);
                 setLayout(mainLayout);
                 //! [9]
             }

src/animations/abstractbaranimation.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "abstractbaranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarAnimation::AbstractBarAnimation(AbstractBarChartItem *item)
                 : ChartAnimation(item),
                   m_item(item)
             {
                 setDuration(ChartAnimationDuration);
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             AbstractBarAnimation::~AbstractBarAnimation()
             {
             }
             QVariant AbstractBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
                 Q_UNUSED(from);
                 Q_UNUSED(to);
                 Q_UNUSED(progress);
                 qWarning() << "AbstractBarAnimation::interpolated called";
                 return to;
             }
             void AbstractBarAnimation::updateCurrentValue(const QVariant &value)
             {
-                QVector<QRectF> layout = qVariantValue<QVector<QRectF> >(value);
+                QVector<QRectF> layout = qvariant_cast<QVector<QRectF> >(value);
                 m_item->setLayout(layout);
             }
             void AbstractBarAnimation::setup(const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
             {
                 QVariantAnimation::KeyValues value;
                 setKeyValues(value); //workaround for wrong interpolation call
                 setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 setKeyValueAt(1.0, qVariantFromValue(newLayout));
             }
             #include "moc_abstractbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/axisanimation.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "axisanimation_p.h"
             #include "chartaxis_p.h"
             #include "chartpresenter_p.h"
             #include <QTimer>
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisAnimation::AxisAnimation(ChartAxis *axis)
                 : ChartAnimation(axis),
                   m_axis(axis),
                   m_type(DefaultAnimation)
             {
                 setDuration(ChartAnimationDuration);
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             AxisAnimation::~AxisAnimation()
             {
             }
             void AxisAnimation::setAnimationType(Animation type)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_type = type;
             }
             void AxisAnimation::setAnimationPoint(const QPointF &point)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_point = point;
             }
             void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
             {
                 if (state() != QAbstractAnimation::Stopped) stop();
                 if (newLayout.count() == 0)
                     return;
                 switch (m_type) {
                 case ZoomOutAnimation: {
                     QRectF rect = m_axis->gridGeometry();
                     oldLayout.resize(newLayout.count());
                     for (int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
                         oldLayout[i] = m_axis->orientation() == Qt::Horizontal ? rect.left() : rect.bottom();
                         oldLayout[j] = m_axis->orientation() == Qt::Horizontal ? rect.right() : rect.top();
                     }
                 }
                 break;
                 case ZoomInAnimation: {
                     int index = qMin(oldLayout.count() * (m_axis->orientation() == Qt::Horizontal ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
                     oldLayout.resize(newLayout.count());
                     for (int i = 0; i < oldLayout.count(); i++)
                         oldLayout[i] = oldLayout[index];
                 }
                 break;
                 case MoveForwardAnimation: {
                     oldLayout.resize(newLayout.count());
                     for (int i = 0, j = i + 1; i < oldLayout.count() - 1; ++i, ++j)
                         oldLayout[i] = oldLayout[j];
                 }
                 break;
                 case MoveBackwordAnimation: {
                     oldLayout.resize(newLayout.count());
                     for (int i = oldLayout.count() - 1, j = i - 1; i > 0; --i, --j)
                         oldLayout[i] = oldLayout[j];
                 }
                 break;
                 default: {
                     oldLayout.resize(newLayout.count());
                     QRectF rect = m_axis->gridGeometry();
                     for (int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
                         oldLayout[i] = m_axis->orientation() == Qt::Horizontal ? rect.left() : rect.top();
                 }
                 break;
                 }
                 QVariantAnimation::KeyValues value;
                 setKeyValues(value); //workaround for wrong interpolation call
                 setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 setKeyValueAt(1.0, qVariantFromValue(newLayout));
             }
             QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
-                QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
+                QVector<qreal> startVector = qvariant_cast<QVector<qreal> >(start);
-                QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
+                QVector<qreal> endVecotr = qvariant_cast<QVector<qreal> >(end);
                 QVector<qreal> result;
                 Q_ASSERT(startVector.count() == endVecotr.count()) ;
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal value = startVector[i] + ((endVecotr[i] - startVector[i]) * progress); //qBound(0.0, progress, 1.0));
                     result << value;
                 }
                 return qVariantFromValue(result);
             }
             void AxisAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
-                    QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
+                    QVector<qreal> vector = qvariant_cast<QVector<qreal> >(value);
                     Q_ASSERT(vector.count() != 0);
                     m_axis->setLayout(vector);
                     m_axis->updateGeometry();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/baranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "baranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarAnimation::BarAnimation(AbstractBarChartItem *item)
                 : AbstractBarAnimation(item)
             {
             }
             BarAnimation::~BarAnimation()
             {
             }
             QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 for (int i = 0; i < startVector.count(); i++) {
                     QRectF start = startVector[i].normalized();
                     QRectF end = endVector[i].normalized();
                     qreal x = end.left();
                     qreal y;
                     qreal w = end.width();
                     qreal h;
                     if (endVector[i].height() < 0) {
                         // Negative bar
                         y = end.top();
                         h = start.height() + ((end.height() - start.height()) * progress);
                     } else {
                         h = startVector[i].height() + ((endVector[i].height() - startVector[i].height()) * progress);
                         y = endVector[i].top() + endVector[i].height() - h;
                     }
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_baranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/horizontalbaranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalbaranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalBarAnimation::HorizontalBarAnimation(AbstractBarChartItem *item)
                 : AbstractBarAnimation(item)
             {
             }
             HorizontalBarAnimation::~HorizontalBarAnimation()
             {
             }
             QVariant HorizontalBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 for (int i = 0; i < startVector.count(); i++) {
                     QRectF start = startVector[i].normalized();
                     QRectF end = endVector[i].normalized();
                     qreal x;
                     qreal y = end.top();
                     qreal w;
                     qreal h = end.height();
                     if (endVector[i].width() < 0) {
                         // Negative bar
                         w = start.width() + ((end.width() - start.width()) * progress);
                         x = endVector[i].right() - endVector[i].width() - w;
                     } else {
                         w = startVector[i].width() + ((endVector[i].width() - startVector[i].width()) * progress);
                         x = end.left();
                     }
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_horizontalbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/horizontalpercentbaranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalpercentbaranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalPercentBarAnimation::HorizontalPercentBarAnimation(AbstractBarChartItem *item) :
                 AbstractBarAnimation(item)
             {
             }
             HorizontalPercentBarAnimation::~HorizontalPercentBarAnimation()
             {
             }
             QVariant HorizontalPercentBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 qreal xAxis = m_item->geometry().x();
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal h = endVector[i].height();
                     qreal w = endVector[i].width() * progress;
                     qreal x = xAxis + ((endVector[i].left() - xAxis) * progress);
                     qreal y = endVector[i].top();
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_horizontalpercentbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/horizontalstackedbaranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalstackedbaranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalStackedBarAnimation::HorizontalStackedBarAnimation(AbstractBarChartItem *item) :
                 AbstractBarAnimation(item)
             {
             }
             HorizontalStackedBarAnimation::~HorizontalStackedBarAnimation()
             {
             }
             QVariant HorizontalStackedBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 qreal xAxis = m_item->geometry().x();
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal h = endVector[i].height();
                     qreal w = endVector[i].width() * progress;
                     qreal x = xAxis + ((endVector[i].left() - xAxis) * progress);
                     qreal y = endVector[i].top();
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_horizontalstackedbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/percentbaranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbaranimation_p.h"
             #include "percentbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarAnimation::PercentBarAnimation(PercentBarChartItem *item)
                 : AbstractBarAnimation(item)
             {
                 setDuration(ChartAnimationDuration);
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             PercentBarAnimation::~PercentBarAnimation()
             {
             }
             QVariant PercentBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 qreal yAxis = m_item->geometry().height() + m_item->geometry().y();
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal w = endVector[i].width();
                     qreal h = startVector[i].height() + ((endVector[i].height() - startVector[i].height()) * progress);
                     qreal x = endVector[i].topLeft().x();
                     qreal y = yAxis + ((endVector[i].topLeft().y() - yAxis) * progress);
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_percentbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/piesliceanimation.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceanimation_p.h"
             #include "piechartitem_p.h"
             Q_DECLARE_METATYPE(QTCOMMERCIALCHART_NAMESPACE::PieSliceData)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             qreal linearPos(qreal start, qreal end, qreal pos)
             {
                 return start + ((end - start) * pos);
             }
             QPointF linearPos(QPointF start, QPointF end, qreal pos)
             {
                 qreal x = linearPos(start.x(), end.x(), pos);
                 qreal y = linearPos(start.y(), end.y(), pos);
                 return QPointF(x, y);
             }
             QPen linearPos(QPen start, QPen end, qreal pos)
             {
                 QColor c;
                 c.setRedF(linearPos(start.color().redF(), end.color().redF(), pos));
                 c.setGreenF(linearPos(start.color().greenF(), end.color().greenF(), pos));
                 c.setBlueF(linearPos(start.color().blueF(), end.color().blueF(), pos));
                 end.setColor(c);
                 return end;
             }
             QBrush linearPos(QBrush start, QBrush end, qreal pos)
             {
                 QColor c;
                 c.setRedF(linearPos(start.color().redF(), end.color().redF(), pos));
                 c.setGreenF(linearPos(start.color().greenF(), end.color().greenF(), pos));
                 c.setBlueF(linearPos(start.color().blueF(), end.color().blueF(), pos));
                 end.setColor(c);
                 return end;
             }
             PieSliceAnimation::PieSliceAnimation(PieSliceItem *sliceItem)
                 : ChartAnimation(sliceItem),
                   m_sliceItem(sliceItem)
             {
             }
             PieSliceAnimation::~PieSliceAnimation()
             {
             }
             void PieSliceAnimation::setValue(const PieSliceData &startValue, const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_currentValue = startValue;
                 setKeyValueAt(0.0, qVariantFromValue(startValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             void PieSliceAnimation::updateValue(const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 setKeyValueAt(0.0, qVariantFromValue(m_currentValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             PieSliceData PieSliceAnimation::currentSliceValue()
             {
                 // NOTE:
                 // We must use an internal current value because QVariantAnimation::currentValue() is updated
                 // before the animation is actually started. So if we get 2 updateValue() calls in a row the currentValue()
                 // will have the end value set from the first call and the second call will interpolate that instead of
                 // the original current value as it was before the first call.
                 return m_currentValue;
             }
             QVariant PieSliceAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
-                PieSliceData startValue = qVariantValue<PieSliceData>(start);
+                PieSliceData startValue = qvariant_cast<PieSliceData>(start);
-                PieSliceData endValue = qVariantValue<PieSliceData>(end);
+                PieSliceData endValue = qvariant_cast<PieSliceData>(end);
                 PieSliceData result;
                 result = endValue;
                 result.m_center = linearPos(startValue.m_center, endValue.m_center, progress);
                 result.m_radius = linearPos(startValue.m_radius, endValue.m_radius, progress);
                 result.m_startAngle = linearPos(startValue.m_startAngle, endValue.m_startAngle, progress);
                 result.m_angleSpan = linearPos(startValue.m_angleSpan, endValue.m_angleSpan, progress);
                 result.m_slicePen = linearPos(startValue.m_slicePen, endValue.m_slicePen, progress);
                 result.m_sliceBrush = linearPos(startValue.m_sliceBrush, endValue.m_sliceBrush, progress);
                 result.m_holeRadius = linearPos(startValue.m_holeRadius, endValue.m_holeRadius, progress);
                 return qVariantFromValue(result);
             }
             void PieSliceAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
-                    m_currentValue = qVariantValue<PieSliceData>(value);
+                    m_currentValue = qvariant_cast<PieSliceData>(value);
                     m_sliceItem->setLayout(m_currentValue);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/splineanimation.cpp +3 -3

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splineanimation_p.h"
             #include "splinechartitem_p.h"
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(SplineVector)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineAnimation::SplineAnimation(SplineChartItem *item)
                 : XYAnimation(item),
                   m_item(item),
                   m_valid(false)
             {
             }
             SplineAnimation::~SplineAnimation()
             {
             }
             void SplineAnimation::setup(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
             {
                 if (newPoints.count() * 2 - 2 != newControlPoints.count() || newControlPoints.count() < 2) {
                     m_valid = false;
                     m_dirty = false;
                     m_item->setGeometryPoints(newPoints);
                     m_item->setControlGeometryPoints(newControlPoints);
                     m_item->setDirty(false);
                     m_item->updateGeometry();
                     return;
                 }
                 m_type = NewAnimation;
                 if (state() != QAbstractAnimation::Stopped) {
                     stop();
                     m_dirty = false;
                 }
                 if (!m_dirty) {
                     m_dirty = true;
                     m_oldSpline.first = oldPoints;
                     m_oldSpline.second = oldControlPoints;
                 }
                 m_newSpline.first = newPoints;
                 m_newSpline.second = newControlPoints;
                 int x = m_oldSpline.first.count();
                 int y = m_newSpline.first.count();
                 if (x - y == 1 && index >= 0 && y > 0) {
                     //remove point
                     if (index > 0) {
                         m_newSpline.first.insert(index, newPoints[index - 1]);
                         m_newSpline.second.insert((index - 1) * 2, newPoints[index - 1]);
                         m_newSpline.second.insert((index - 1) * 2 + 1, newPoints[index - 1]);
                     } else {
                         m_newSpline.first.insert(index, newPoints[index]);
                         m_newSpline.second.insert(index * 2, newPoints[index]);
                         m_newSpline.second.insert(index * 2 + 1, newPoints[index]);
                     }
                     m_index = index;
                     m_type = RemovePointAnimation;
                 }
                 if (x - y == -1 && index >= 0) {
                     //add point
                     if (index > 0) {
                         m_oldSpline.first.insert(index, newPoints[index - 1]);
                         m_oldSpline.second.insert((index - 1) * 2, newPoints[index - 1]);
                         m_oldSpline.second.insert((index - 1) * 2 + 1, newPoints[index - 1]);
                     } else {
                         m_oldSpline.first.insert(index, newPoints[index]);
                         m_oldSpline.second.insert((index - 1) * 2, newPoints[index]);
                         m_oldSpline.second.insert((index - 1) * 2 + 1, newPoints[index]);
                     }
                     m_index = index;
                     m_type = AddPointAnimation;
                 }
                 x = m_oldSpline.first.count();
                 y = m_newSpline.first.count();
                 if (x != y) {
                     m_type = NewAnimation;
                 } else if (m_type == NewAnimation) {
                     m_type = ReplacePointAnimation;
                 }
                 setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
                 setKeyValueAt(1.0, qVariantFromValue(m_newSpline));
                 m_valid = true;
             }
             QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
-                SplineVector startPair = qVariantValue< SplineVector >(start);
+                SplineVector startPair = qvariant_cast< SplineVector >(start);
-                SplineVector endPair = qVariantValue< SplineVector >(end);
+                SplineVector endPair = qvariant_cast< SplineVector >(end);
                 SplineVector result;
                 switch (animationType()) {
                 case RemovePointAnimation:
                 case AddPointAnimation:
                 case ReplacePointAnimation: {
                     if (startPair.first.count() != endPair.first.count())
                         break;
                     Q_ASSERT(startPair.first.count() * 2 - 2 == startPair.second.count());
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     for (int i = 0; i < endPair.first.count(); i++) {
                         qreal x = startPair.first[i].x() + ((endPair.first[i].x() - startPair.first[i].x()) * progress);
                         qreal y = startPair.first[i].y() + ((endPair.first[i].y() - startPair.first[i].y()) * progress);
                         result.first << QPointF(x, y);
                         if (i + 1 >= endPair.first.count())
                             continue;
                         x = startPair.second[i * 2].x() + ((endPair.second[i * 2].x() - startPair.second[i * 2].x()) * progress);
                         y = startPair.second[i * 2].y() + ((endPair.second[i * 2].y() - startPair.second[i * 2].y()) * progress);
                         result.second << QPointF(x, y);
                         x = startPair.second[i * 2 + 1].x() + ((endPair.second[i * 2 + 1].x() - startPair.second[i * 2 + 1].x()) * progress);
                         y = startPair.second[i * 2 + 1].y() + ((endPair.second[i * 2 + 1].y() - startPair.second[i * 2 + 1].y()) * progress);
                         result.second << QPointF(x, y);
                     }
                 }
                 break;
                 case NewAnimation: {
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     int count = endPair.first.count() * qBound(qreal(0), progress, qreal(1));
                     for (int i = 0; i < count; i++) {
                         result.first << endPair.first[i];
                         if (i + 1 == count)
                             break;
                         result.second << endPair.second[2 * i];
                         result.second << endPair.second[2 * i + 1];
                     }
                 }
                 break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void SplineAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped && m_valid) { //workaround
-                    QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
+                    QPair<QVector<QPointF >, QVector<QPointF > > pair = qvariant_cast< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
                     m_item->setGeometryPoints(pair.first);
                     m_item->setControlGeometryPoints(pair.second);
                     m_item->updateGeometry();
                     m_item->setDirty(true);
                     m_dirty = false;
                 }
             }
             void SplineAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
             {
                 XYAnimation::updateState(newState, oldState);
                 if (oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped) {
                     if (m_item->isDirty() && m_type == RemovePointAnimation) {
                         if (!m_newSpline.first.isEmpty()) {
                             m_newSpline.first.remove(m_index);
                             m_newSpline.second.remove((m_index - 1) * 2);
                             m_newSpline.second.remove((m_index - 1) * 2);
                         }
                         m_item->setGeometryPoints(m_newSpline.first);
                         m_item->setControlGeometryPoints(m_newSpline.second);
                     }
                 }
                 if (oldState == QAbstractAnimation::Stopped && newState == QAbstractAnimation::Running) {
                     if (!m_valid)
                         stop();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/stackedbaranimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbaranimation_p.h"
             #include "stackedbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarAnimation::StackedBarAnimation(StackedBarChartItem *item)
                 : AbstractBarAnimation(item)
             {
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             StackedBarAnimation::~StackedBarAnimation()
             {
             }
             QVariant StackedBarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
+                QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
-                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
+                QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 qreal yAxis = m_item->geometry().height() + m_item->geometry().y();
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal w = endVector[i].width();
                     qreal h = startVector[i].height() + ((endVector[i].height() - startVector[i].height()) * progress);
                     qreal x = endVector[i].topLeft().x();
                     qreal y = yAxis + ((endVector[i].topLeft().y() - yAxis) * progress);
                     QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
             #include "moc_stackedbaranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "xyanimation_p.h"
             #include "xychart_p.h"
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYAnimation::XYAnimation(XYChart *item)
                 : ChartAnimation(item),
                   m_type(NewAnimation),
                   m_dirty(false),
                   m_index(-1),
                   m_item(item)
             {
                 setDuration(ChartAnimationDuration);
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             XYAnimation::~XYAnimation()
             {
             }
             void XYAnimation::setup(const QVector<QPointF> &oldPoints, const QVector<QPointF> &newPoints, int index)
             {
                 m_type = NewAnimation;
                 if (state() != QAbstractAnimation::Stopped) {
                     stop();
                     m_dirty = false;
                 }
                 if (!m_dirty) {
                     m_dirty = true;
                     m_oldPoints = oldPoints;
                 }
                 m_newPoints = newPoints;
                 int x = m_oldPoints.count();
                 int y = m_newPoints.count();
                 if (x - y == 1  && index >= 0 && y > 0) {
                     //remove point
                     m_newPoints.insert(index, index > 0 ? newPoints[index - 1] : newPoints[index]);
                     m_index = index;
                     m_type = RemovePointAnimation;
                 }
                 if (x - y == -1  && index >= 0) {
                     //add point
                     m_oldPoints.insert(index, index > 0 ? newPoints[index - 1] : newPoints[index]);
                     m_index = index;
                     m_type = AddPointAnimation;
                 }
                 x = m_oldPoints.count();
                 y = m_newPoints.count();
                 if (x != y)
                     m_type = NewAnimation;
                 else if (m_type == NewAnimation)
                     m_type = ReplacePointAnimation;
                 setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
                 setKeyValueAt(1.0, qVariantFromValue(m_newPoints));
             }
             QVariant XYAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
-                QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
+                QVector<QPointF> startVector = qvariant_cast<QVector<QPointF> >(start);
-                QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
+                QVector<QPointF> endVector = qvariant_cast<QVector<QPointF> >(end);
                 QVector<QPointF> result;
                 switch (m_type) {
                 case ReplacePointAnimation:
                 case AddPointAnimation:
                 case RemovePointAnimation: {
                     if (startVector.count() != endVector.count())
                         break;
                     for (int i = 0; i < startVector.count(); i++) {
                         qreal x = startVector[i].x() + ((endVector[i].x() - startVector[i].x()) * progress);
                         qreal y = startVector[i].y() + ((endVector[i].y() - startVector[i].y()) * progress);
                         result << QPointF(x, y);
                     }
                 }
                 break;
                 case NewAnimation: {
                     for (int i = 0; i < endVector.count() * qBound(qreal(0), progress, qreal(1)); i++)
                         result << endVector[i];
                 }
                 break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void XYAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
-                    QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
+                    QVector<QPointF> vector = qvariant_cast<QVector<QPointF> >(value);
                     m_item->setGeometryPoints(vector);
                     m_item->updateGeometry();
                     m_item->setDirty(true);
                     m_dirty = false;
                 }
             }
             void XYAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
             {
                 if (oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped) {
                     if (m_item->isDirty() && m_type == RemovePointAnimation) {
                         if (!m_newPoints.isEmpty())
                             m_newPoints.remove(m_index);
                         m_item->setGeometryPoints(m_newPoints);
                     }
                 }
             }
             #include "moc_chartanimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartElement(presenter),
                   m_chartAxis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                   m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                   m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                   m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                   m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
                   m_min(0),
                   m_max(0),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(), SIGNAL(updated()), this, SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
-                if (m_arrow->children().size() == 0)
+                if (m_arrow->childItems().size() == 0)
                     m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
-                if (m_intervalAxis && m_grid->children().size() == 0) {
+                if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++)
                         m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                 }
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
                     label->setFont(m_font);
                     m_labels->addToGroup(label);
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
                         m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (diff < 0) handleAxisUpdated();
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 if (m_font != font) {
                     m_font = font;
                     foreach (QGraphicsItem *item , m_labels->childItems())
                         static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain *domain = qobject_cast<Domain *>(sender());
                 qreal min(0);
                 qreal max(0);
                 if (m_chartAxis->orientation() == Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 } else if (m_chartAxis->orientation() == Qt::Vertical) {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                         QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                         QSizeF after = sizeHint(Qt::PreferredSize);
                         if (before != after) {
                             QGraphicsLayoutItem::updateGeometry();
                             //we don't want to call invalidate on layout, since it will change minimum size of component,
                             //which we would like to avoid since it causes nasty flips when scrolling or zooming,
                             //instead recalculate layout and use plotArea for extra space.
                             presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                         }
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty())
                     return;
                 bool visible = m_chartAxis->isVisible();
                 //TODO: split this into separate signal/slots ?
                 setArrowVisibility(visible && m_chartAxis->isLineVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->linePen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
                 setTitleText(m_chartAxis->title());
                 setTitleFont(m_chartAxis->titleFont());
                 setTitlePen(m_chartAxis->titlePen());
                 setTitleBrush(m_chartAxis->titleBrush());
             }
             void ChartAxis::setTitleText(const QString &title)
             {
                 if (m_titleText != title) {
                     m_titleText = title;
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setTitlePen(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::setTitleBrush(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::setTitleFont(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             QFont ChartAxis::titleFont() const
             {
                 return  m_title->font();
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::axisSelected()
             {
                 //TODO: axis clicked;
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_chartAxis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_chartAxis->alignment();
             }
             bool ChartAxis::isVisible()
             {
                 return m_chartAxis->isVisible();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QStringList ChartAxis::createValueLabels(int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-qFloor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 QString format = axis->labelFormat();
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
-                    QByteArray array = format.toAscii();
+                    QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(const QString &format, int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-floor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarkerItem::LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 m_marker(marker),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
                 m_margin(4),
                 m_space(4),
                 m_hovering(false),
                 m_pressPos(0, 0)
             {
                 m_rectItem->setRect(m_markerRect);
-                setAcceptsHoverEvents(true);
+                setAcceptHoverEvents(true);
             }
             LegendMarkerItem::~LegendMarkerItem()
             {
                 if (m_hovering) {
                     emit m_marker->q_ptr->hovered(false);
                 }
             }
             void LegendMarkerItem::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
             }
             QPen LegendMarkerItem::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarkerItem::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarkerItem::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 QFontMetrics fn(font);
                 m_markerRect = QRectF(0,0,fn.height()/2,fn.height()/2);
                 updateGeometry();
             }
             QFont LegendMarkerItem::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarkerItem::setLabel(const QString label)
             {
                 m_label = label;
                 updateGeometry();
             }
             QString LegendMarkerItem::label() const
             {
                 return m_label;
             }
             void LegendMarkerItem::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::labelBrush() const
             {
                 return m_textItem->brush();
             }
             void LegendMarkerItem::setGeometry(const QRectF &rect)
             {
                 QFontMetrics fn (m_font);
                 int width = rect.width();
                 qreal x = m_margin + m_markerRect.width() +  m_space + m_margin;
                 qreal y = qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin);
                 if (fn.boundingRect(m_label).width() + x > width)
                 {
                     QString string = m_label + "...";
                     while(fn.boundingRect(string).width() + x > width && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                     m_textItem->setText(string);
                 }
                 else
                     m_textItem->setText(m_label);
                 const QRectF &textRect = m_textItem->boundingRect();
                 m_textItem->setPos(x-m_margin,y/2 - textRect.height()/2);
                 m_rectItem->setRect(m_markerRect);
                 m_rectItem->setPos(m_margin,y/2  - m_markerRect.height()/2);
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,x+textRect.width()+m_margin,y);
             }
             QRectF LegendMarkerItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarkerItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarkerItem::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(m_textItem->font());
                 QSizeF sh;
                   switch (which) {
                     case Qt::MinimumSize:
                         sh = QSizeF(fn.boundingRect("...").width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     case Qt::PreferredSize:
                         sh = QSizeF(fn.boundingRect(m_label).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     default:
                       break;
                   }
                   return sh;
             }
             void LegendMarkerItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = true;
                 emit m_marker->q_ptr->hovered(true);
             }
             void LegendMarkerItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = false;
                 emit m_marker->q_ptr->hovered(false);
             }
             #include "moc_legendmarkeritem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/inc/tst_definitions.h +11 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef TST_DEFINITIONS_H
             #define TST_DEFINITIONS_H
             #include <QtTest/QtTest>
             #include <QPushButton>
+            #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+            namespace QTest
+            {
+                // This was deprecated in Qt5. This is a small hack for the sake of compatibility.
+                inline static bool qWaitForWindowShown(QWidget *window)
+                {
+                    return QTest::qWaitForWindowExposed(window);
+                }
+            }
+            #endif
             #define TRY_COMPARE(actual, expected) { \
                 do { \
                     const int timeout(1000); \
                     const int waitStep(30); \
                     /* always wait before comparing to catch possible extra signals */ \
                     QTest::qWait(waitStep); \
                     for (int time(0); (actual != expected) && (time < timeout); time += waitStep) \
                         QTest::qWait(waitStep); \
                     QCOMPARE(actual, expected); \
                 } while (0); \
             }
             // Some bamboo clients have trouble passing mouse events to the test application.
             // This can be used to skip those tests so that they don't show up as a failure
             // in the test report.
             #ifdef QT5_QUICK_1
             #define SKIP_IF_CANNOT_TEST_MOUSE_EVENTS() { \
                 do { \
                     QPushButton b; \
                     b.resize(100, 100); \
                     b.show(); \
                     QTest::qWaitForWindowShown(&b); \
                     QSignalSpy spy(&b, SIGNAL(clicked())); \
                     QTest::mouseClick(&b, Qt::LeftButton, 0, b.rect().center()); \
                     if (spy.count() == 0) \
                         QSKIP("Cannot test mouse events in this environment"); \
                 } while (0); \
             }
             #else
             #define SKIP_IF_CANNOT_TEST_MOUSE_EVENTS() { \
                 do { \
                     QPushButton b; \
                     b.resize(100, 100); \
                     b.show(); \
                     QTest::qWaitForWindowShown(&b); \
                     QSignalSpy spy(&b, SIGNAL(clicked())); \
                     QTest::mouseClick(&b, Qt::LeftButton, 0, b.rect().center()); \
                     if (spy.count() == 0) \
                         QSKIP("Cannot test mouse events in this environment", SkipAll); \
                 } while (0); \
             }
             #endif
             #endif // TST_DEFINITIONS_H

tests/auto/qbarset/tst_qbarset.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qchartview.h>
+            #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QBarSet : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarset_data();
                 void qbarset();
                 void label_data();
                 void label();
                 void append_data();
                 void append();
                 void appendOperator_data();
                 void appendOperator();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 void replace_data();
                 void replace();
                 void at_data();
                 void at();
                 void atOperator_data();
                 void atOperator();
                 void count_data();
                 void count();
                 void sum_data();
                 void sum();
                 void customize();
             private:
                 QBarSet* m_barset;
             };
             void tst_QBarSet::initTestCase()
             {
             }
             void tst_QBarSet::cleanupTestCase()
             {
             }
             void tst_QBarSet::init()
             {
                  m_barset = new QBarSet(QString("label"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
                 QBarSet barset(QString("label"));
                 QCOMPARE(barset.label(), QString("label"));
                 QCOMPARE(barset.count(), 0);
                 QVERIFY(qFuzzyIsNull(barset.sum()));
             }
             void tst_QBarSet::label_data()
             {
                 QTest::addColumn<QString> ("label");
                 QTest::addColumn<QString> ("result");
                 QTest::newRow("label0") << QString("label0") << QString("label0");
                 QTest::newRow("label1") << QString("label1") << QString("label1");
             }
             void tst_QBarSet::label()
             {
                 QFETCH(QString, label);
                 QFETCH(QString, result);
                 QSignalSpy labelSpy(m_barset,SIGNAL(labelChanged()));
                 m_barset->setLabel(label);
                 QCOMPARE(m_barset->label(), result);
                 QVERIFY(labelSpy.count() == 1);
             }
             void tst_QBarSet::append_data()
             {
                 QTest::addColumn<int> ("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("100") << 100;
                 QTest::newRow("1000") << 1000;
             }
             void tst_QBarSet::append()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset, SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     m_barset->append(value);
                     QCOMPARE(m_barset->at(i), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QCOMPARE(valueSpy.count(), count);
             }
             void tst_QBarSet::appendOperator_data()
             {
                 append_data();
             }
             void tst_QBarSet::appendOperator()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     *m_barset << value;
                     QCOMPARE(m_barset->at(i), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QCOMPARE(valueSpy.count(), count);
             }
             void tst_QBarSet::insert_data()
             {
             }
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 m_barset->insert(0, 1.0);       // 1.0
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->count(), 1);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)1.0));
                 m_barset->insert(0, 2.0);       // 2.0 1.0
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(1), 1.0);
                 QCOMPARE(m_barset->count(), 2);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)3.0));
                 m_barset->insert(1, 3.0);       // 2.0 3.0 1.0
                 QCOMPARE(m_barset->at(1), 3.0);
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(2), 1.0);
                 QCOMPARE(m_barset->count(), 3);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)6.0));
                 QCOMPARE(valueSpy.count(), 3);
             }
             void tst_QBarSet::remove_data()
             {
             }
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesRemoved(int,int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 // Remove middle
                 m_barset->remove(2);                // 1.0 2.0 4.0
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 4.0);
                 QCOMPARE(m_barset->count(), 3);
                 QCOMPARE(m_barset->sum(), 7.0);
                 QCOMPARE(valueSpy.count(), 1);
                 QList<QVariant> valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 2);
                 // Verify count of removed signal
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 1);
                 // Remove first
                 m_barset->remove(0);                // 2.0 4.0
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(1), 4.0);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 QCOMPARE(valueSpy.count(), 1);
                 valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 0);
                 // Verify count of removed signal
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 1);
                 // Illegal indexes
                 m_barset->remove(4);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 m_barset->remove(-1);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 // nothing removed, no signals should be emitted
                 QCOMPARE(valueSpy.count(), 0);
                 // Remove more items than list has
                 m_barset->remove(0,312);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QCOMPARE(valueSpy.count(), 1);
                 valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 0);
                 // Verify count of removed signal (expect 2 values removed, because list had only 2 items)
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 2);
             }
             void tst_QBarSet::replace_data()
             {
             }
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valueChanged(int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 // Replace first
                 m_barset->replace(0, 5.0);          // 5.0 2.0 3.0 4.0
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 14.0);
                 QCOMPARE(m_barset->at(0), 5.0);
                 // Replace last
                 m_barset->replace(3, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QCOMPARE(m_barset->at(0), 5.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 3.0);
                 QCOMPARE(m_barset->at(3), 6.0);
                 // Illegal indexes
                 m_barset->replace(4, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(-1, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(4, 1.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(-1, 1.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QVERIFY(valueSpy.count() == 2);
             }
             void tst_QBarSet::at_data()
             {
             }
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 3.0);
                 QCOMPARE(m_barset->at(3), 4.0);
             }
             void tst_QBarSet::atOperator_data()
             {
             }
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->operator [](0), 1.0);
                 QCOMPARE(m_barset->operator [](1), 2.0);
                 QCOMPARE(m_barset->operator [](2), 3.0);
                 QCOMPARE(m_barset->operator [](3), 4.0);
             }
             void tst_QBarSet::count_data()
             {
             }
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
                 m_barset->append(2.0);
                 QCOMPARE(m_barset->count(),2);
                 m_barset->append(3.0);
                 QCOMPARE(m_barset->count(),3);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(),4);
             }
             void tst_QBarSet::sum_data()
             {
             }
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)1.0));
                 m_barset->append(2.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)3.0));
                 m_barset->append(3.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)6.0));
                 m_barset->append(4.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)10.0));
             }
             void tst_QBarSet::customize()
             {
                 // Create sets
                 QBarSet *set1 = new QBarSet("set1");
                 QBarSet *set2 = new QBarSet("set2");
                 // Append set1 to series
                 QBarSeries *series = new QBarSeries();
                 bool success = series->append(set1);
                 QVERIFY(success);
                 // Add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test pen
                 QVERIFY(set1->pen() != QPen());
                 QVERIFY(set2->pen() == QPen());
                 QPen pen(QColor(128,128,128,128));
                 set1->setPen(pen);
                 // Add sets back to series
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->pen() == pen);      // Should be customized
                 QVERIFY(set2->pen() != QPen());   // Should be decorated by theme
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test brush
                 set2->setBrush(QBrush());
                 QVERIFY(set1->brush() != QBrush());
                 QVERIFY(set2->brush() == QBrush());
                 QBrush brush(QColor(128,128,128,128));
                 set1->setBrush(brush);
                 // Add sets back to series
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->brush() == brush);    // Should be customized
                 QVERIFY(set2->brush() != QBrush()); // Should be decorated by theme
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test label brush
                 set2->setLabelBrush(QBrush());
                 QVERIFY(set1->labelBrush() != QBrush());
                 QVERIFY(set2->labelBrush() == QBrush());
                 set1->setLabelBrush(brush);
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->labelBrush() == brush);       // Should be customized
                 QVERIFY(set2->labelBrush() != QBrush());    // Should be decorated by theme
                 // Test label font
                 // Note: QFont empty constructor creates font with application's default font, so the font may or may not be the
                 // same for the set added to the series  (depending on the QChart's theme configuration)
                 QVERIFY(set1->labelFont() != QFont() || set1->labelFont() == QFont());
                 QVERIFY(set2->labelFont() == QFont());
                 QFont font;
                 font.setBold(true);
                 font.setItalic(true);
                 set1->setLabelFont(font);
                 QVERIFY(set1->labelFont() == font);
                 QVERIFY(set2->labelFont() == QFont());
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
             }
             QTEST_MAIN(tst_QBarSet)
             #include "tst_qbarset.moc"

tests/auto/qchart/tst_qchart.cpp +104 -103

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qabstractbarseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qvalueaxis.h>
             #include <qbarcategoryaxis.h>
+            #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void plotArea_data();
                 void plotArea();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scroll_right_data();
                 void scroll_right();
                 void scroll_left_data();
                 void scroll_left();
                 void scroll_up_data();
                 void scroll_up();
                 void scroll_down_data();
                 void scroll_down();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::createTestData()
             {
                  QLineSeries* series0 = new QLineSeries(this);
                  *series0 << QPointF(0, 0) << QPointF(100, 100);
                  m_chart->addSeries(series0);
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(!m_chart->axisX());
                 QVERIFY(!m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->plotArea().top()==0);
                 QVERIFY(m_chart->plotArea().left()==0);
                 QVERIFY(m_chart->plotArea().right()==0);
                 QVERIFY(m_chart->plotArea().bottom()==0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scroll(0,0);
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
                 m_view->show();
                 QVERIFY(m_chart->plotArea().top()>0);
                 QVERIFY(m_chart->plotArea().left()>0);
                 QVERIFY(m_chart->plotArea().right()>0);
                 QVERIFY(m_chart->plotArea().bottom()>0);
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("lineSeries") << line;
                 QTest::newRow("areaSeries") << area;
                 QTest::newRow("scatterSeries") << scatter;
                 QTest::newRow("splineSeries") << spline;
                 QTest::newRow("pieSeries") << pie;
                 QTest::newRow("barSeries") << bar;
                 QTest::newRow("percentBarSeries") << percent;
                 QTest::newRow("stackedBarSeries") << stacked;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
                 m_chart->addSeries(series);
                 QCOMPARE(m_chart->series().count(), 1);
                 QCOMPARE(m_chart->series().first(), series);
                 QVERIFY(series->chart() == m_chart);
                 m_chart->createDefaultAxes();
                 if(series->type()!=QAbstractSeries::SeriesTypePie){
                     QVERIFY(m_chart->axisY(series));
                     QVERIFY(m_chart->axisX(series));
                 }else{
                     QVERIFY(!m_chart->axisY(series));
                     QVERIFY(!m_chart->axisX(series));
                 }
                 m_chart->removeSeries(series);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::newRow("categories,lineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() <<  (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
             }
             void tst_QChart::axisX()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisX());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisX(axis,series);
                 QVERIFY(m_chart->axisX(series)==axis);
             }
             void tst_QChart::axisY_data()
             {
                 axisX_data();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisY());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QVERIFY(m_chart->axisY(series)==axis);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::plotArea_data()
             {
             }
             void tst_QChart::plotArea()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->plotArea().isValid());
                 QVERIFY(m_chart->plotArea().height() < rect.height());
                 QVERIFY(m_chart->plotArea().width() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->createDefaultAxes();
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
                 QCOMPARE(deleteSpy1.count(), 1);
                 QCOMPARE(deleteSpy2.count(), 1);
                 QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 axisX_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractAxis *, axis);
                 QFETCH(QAbstractSeries *, series);
                 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
                 QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scroll_right_data()
             {
-            	 QTest::addColumn<QAbstractSeries *>("series");
+                 QTest::addColumn<QAbstractSeries *>("series");
-            	 QLineSeries* series0 = new QLineSeries(this);
+                 QLineSeries* series0 = new QLineSeries(this);
-            	 *series0 << QPointF(0, 0) << QPointF(100, 100);
+                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                  QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
             }
             void tst_QChart::scroll_right()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisX();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
-                		QVERIFY(vaxis!=0);
+                        QVERIFY(vaxis!=0);
-                		qreal min = vaxis->min();
+                        qreal min = vaxis->min();
-                		qreal max = vaxis->max();
+                        qreal max = vaxis->max();
-                		QVERIFY(max>min);
+                        QVERIFY(max>min);
-                		m_chart->scroll(50, 0);
+                        m_chart->scroll(50, 0);
-                		QVERIFY(min<vaxis->min());
+                        QVERIFY(min<vaxis->min());
-                		QVERIFY(max<vaxis->max());
+                        QVERIFY(max<vaxis->max());
-                		break;
+                        break;
+                    }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
-                	   	QVERIFY(caxis!=0);
+                        QVERIFY(caxis!=0);
-                	   	qreal min = caxis->min().toDouble();
+                        qreal min = caxis->min().toDouble();
-                	   	qreal max = caxis->max().toDouble();
+                        qreal max = caxis->max().toDouble();
-                	   	m_chart->scroll(50, 0);
+                        m_chart->scroll(50, 0);
-                	   	QVERIFY(min<caxis->min().toDouble());
+                        QVERIFY(min<caxis->min().toDouble());
-                	   	QVERIFY(max<caxis->max().toDouble());
+                        QVERIFY(max<caxis->max().toDouble());
-                		break;
+                        break;
+                    }
-                	default:
+                    default:
-                		qFatal("Unsupported type");
+                        qFatal("Unsupported type");
-                		break;
+                        break;
                 }
             }
             void tst_QChart::scroll_left_data()
             {
-            	scroll_right_data();
+                scroll_right_data();
             }
             void tst_QChart::scroll_left()
             {
-            	 QFETCH(QAbstractSeries *, series);
+                 QFETCH(QAbstractSeries *, series);
-            	 m_chart->addSeries(series);
+                 m_chart->addSeries(series);
-            	 m_chart->createDefaultAxes();
+                 m_chart->createDefaultAxes();
-            	 m_view->show();
+                 m_view->show();
-            	 QTest::qWaitForWindowShown(m_view);
+                 QTest::qWaitForWindowShown(m_view);
-            	 QAbstractAxis * axis = m_chart->axisX();
+                 QAbstractAxis * axis = m_chart->axisX();
-            	 QVERIFY(axis!=0);
+                 QVERIFY(axis!=0);
-            	 switch(axis->type())
+                 switch(axis->type())
+                    {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
-            	    		QVERIFY(vaxis!=0);
+                            QVERIFY(vaxis!=0);
-            	    		qreal min = vaxis->min();
+                            qreal min = vaxis->min();
-            	    		qreal max = vaxis->max();
+                            qreal max = vaxis->max();
-            	    		m_chart->scroll(-50, 0);
+                            m_chart->scroll(-50, 0);
-            	    		QVERIFY(min>vaxis->min());
+                            QVERIFY(min>vaxis->min());
-            	    		QVERIFY(max>vaxis->max());
+                            QVERIFY(max>vaxis->max());
-            	    		break;
+                            break;
+                        }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
-            	    	   	QVERIFY(caxis!=0);
+                            QVERIFY(caxis!=0);
-            	    	   	qreal min = caxis->min().toDouble();
+                            qreal min = caxis->min().toDouble();
-            	    	   	qreal max = caxis->max().toDouble();
+                            qreal max = caxis->max().toDouble();
-            	    	   	m_chart->scroll(-50, 0);
+                            m_chart->scroll(-50, 0);
-            	    	   	QVERIFY(min>caxis->min().toDouble());
+                            QVERIFY(min>caxis->min().toDouble());
-            	    	   	QVERIFY(max>caxis->max().toDouble());
+                            QVERIFY(max>caxis->max().toDouble());
-            	    		break;
+                            break;
+                        }
-            	    	default:
+                        default:
-            	    		qFatal("Unsupported type");
+                            qFatal("Unsupported type");
-            	    		break;
+                            break;
+                    }
             }
             void tst_QChart::scroll_up_data()
             {
-            	scroll_right_data();
+                scroll_right_data();
             }
             void tst_QChart::scroll_up()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisY();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
-                		QVERIFY(vaxis!=0);
+                        QVERIFY(vaxis!=0);
-                		qreal min = vaxis->min();
+                        qreal min = vaxis->min();
-                		qreal max = vaxis->max();
+                        qreal max = vaxis->max();
-                		m_chart->scroll(0, 50);
+                        m_chart->scroll(0, 50);
-                		QVERIFY(min<vaxis->min());
+                        QVERIFY(min<vaxis->min());
-                		QVERIFY(max<vaxis->max());
+                        QVERIFY(max<vaxis->max());
-                		break;
+                        break;
+                    }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
-                	   	QVERIFY(caxis!=0);
+                        QVERIFY(caxis!=0);
-                	   	qreal min = caxis->min().toDouble();
+                        qreal min = caxis->min().toDouble();
-                	   	qreal max = caxis->max().toDouble();
+                        qreal max = caxis->max().toDouble();
-                	   	m_chart->scroll(0, 50);
+                        m_chart->scroll(0, 50);
-                	   	QVERIFY(min<caxis->min().toDouble());
+                        QVERIFY(min<caxis->min().toDouble());
-                	   	QVERIFY(max<caxis->max().toDouble());
+                        QVERIFY(max<caxis->max().toDouble());
-                		break;
+                        break;
+                    }
-                	default:
+                    default:
-                		qFatal("Unsupported type");
+                        qFatal("Unsupported type");
-                		break;
+                        break;
                 }
             }
             void tst_QChart::scroll_down_data()
             {
-            	scroll_right_data();
+                scroll_right_data();
             }
             void tst_QChart::scroll_down()
             {
-            	 QFETCH(QAbstractSeries *, series);
+                 QFETCH(QAbstractSeries *, series);
-            	 m_chart->addSeries(series);
+                 m_chart->addSeries(series);
-            	 m_chart->createDefaultAxes();
+                 m_chart->createDefaultAxes();
-            	 m_view->show();
+                 m_view->show();
-            	 QTest::qWaitForWindowShown(m_view);
+                 QTest::qWaitForWindowShown(m_view);
-            	 QAbstractAxis * axis = m_chart->axisY();
+                 QAbstractAxis * axis = m_chart->axisY();
-            	 QVERIFY(axis!=0);
+                 QVERIFY(axis!=0);
-            	 switch(axis->type())
+                 switch(axis->type())
+                    {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
-            	    		QVERIFY(vaxis!=0);
+                            QVERIFY(vaxis!=0);
-            	    		qreal min = vaxis->min();
+                            qreal min = vaxis->min();
-            	    		qreal max = vaxis->max();
+                            qreal max = vaxis->max();
-            	    		m_chart->scroll(0, -50);
+                            m_chart->scroll(0, -50);
-            	    		QVERIFY(min>vaxis->min());
+                            QVERIFY(min>vaxis->min());
-            	    		QVERIFY(max>vaxis->max());
+                            QVERIFY(max>vaxis->max());
-            	    		break;
+                            break;
+                        }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
-            	    	   	QVERIFY(caxis!=0);
+                            QVERIFY(caxis!=0);
-            	    	   	qreal min = caxis->min().toDouble();
+                            qreal min = caxis->min().toDouble();
-            	    	   	qreal max = caxis->max().toDouble();
+                            qreal max = caxis->max().toDouble();
-            	    	   	m_chart->scroll(0, -50);
+                            m_chart->scroll(0, -50);
-            	    	   	QVERIFY(min>caxis->min().toDouble());
+                            QVERIFY(min>caxis->min().toDouble());
-            	    	   	QVERIFY(max>caxis->max().toDouble());
+                            QVERIFY(max>caxis->max().toDouble());
-            	    		break;
+                            break;
+                        }
-            	    	default:
+                        default:
-            	    		qFatal("Unsupported type");
+                            qFatal("Unsupported type");
-            	    		break;
+                            break;
+                    }
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 m_chart->createDefaultAxes();
                 QRectF marigns = m_chart->plotArea();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<axisX->min());
                     QVERIFY(maxX>axisX->max());
                     QVERIFY(minY<axisY->min());
                     QVERIFY(maxY>axisY->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 m_chart->createDefaultAxes();
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < axisX->min());
                 QVERIFY(maxX > axisX->max());
                 QVERIFY(minY < axisY->min());
                 QVERIFY(maxY > axisY->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(axisX->min()));
                 else
                     QCOMPARE(minX, axisX->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(axisY->min()));
                 else
                     QCOMPARE(minY, axisY->min());
                 QVERIFY(maxX == axisX->max());
                 QVERIFY(maxY == axisY->max());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

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