HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2439:8946feb2c29e

Remove cryptic/obsolete TODOs

Miikka Heikkinen -

r2439:8946feb2c29e

parent child

Context file:

r2439:8946feb2c29e

Collapse all files

plugins/designer/qchartsplugin.cpp 0 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qchartsplugin.h"
             #include "qchartview.h"
             #include <QtPlugin>
             QTCOMMERCIALCHART_USE_NAMESPACE
             QChartsPlugin::QChartsPlugin(QObject *parent) :
                 QObject(parent)
             {
-                // TODO Auto-generated constructor stub
             }
             QChartsPlugin::~QChartsPlugin()
             {
-                // TODO Auto-generated destructor stub
             }
             QString QChartsPlugin::name() const
             {
                 return "QChartView";
             }
             QString QChartsPlugin::includeFile() const
             {
             #ifdef linux
                 QString myNewLine = "\n";
             #endif
             #ifdef WIN32
                 QString myNewLine = "\n\r";
             #endif
             #ifdef __APPLE__
                 QString myNewLine = "\n";
             #endif
                 return "<qchartview.h>" + myNewLine + "#include <chartsnamespace.h>";
             }
             QString QChartsPlugin::group() const
             {
                 return tr("QCharts Widgets");
             }
             QIcon QChartsPlugin::icon() const
             {
                 return QIcon(":/images/qcharts.png");
             }
             QString QChartsPlugin::toolTip() const
             {
                 return tr("An qcharts view widget");
             }
             QString QChartsPlugin::whatsThis() const
             {
                 return tr("This widget is presents QChartView widget");
             }
             bool QChartsPlugin::isContainer() const
             {
                 return false;
             }
             QWidget *QChartsPlugin::createWidget(QWidget *parent)
             {
                 return new QChartView(new QChart(), parent);
             }
             #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
                 Q_EXPORT_PLUGIN2(qtcommercialchart, QChartsPlugin)
             #endif

src/areachart/areachartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item)
-                : ChartItem(areaSeries->d_func(),item), //TODO: fix me
+                : ChartItem(areaSeries->d_func(),item),
                   m_series(areaSeries),
                   m_upper(0),
                   m_lower(0),
                   m_pointsVisible(false)
             {
                 setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this, m_series->upperSeries());
                 if (m_series->lowerSeries())
                     m_lower = new AreaBoundItem(this, m_series->lowerSeries());
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), areaSeries, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), areaSeries, SIGNAL(hovered(QPointF,bool)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             void AreaChartItem::setPresenter(ChartPresenter *presenter)
             {
                 m_upper->setPresenter(presenter);
                 if (m_lower) {
                     m_lower->setPresenter(presenter);
                 }
             	ChartItem::setPresenter(presenter);
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 QRectF rect(QPointF(0,0),domain()->size());
                 path = m_upper->path();
                 if (m_lower) {
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(), rect.bottom());
                     path.lineTo(first.x(), rect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path = path;
                 m_rect = path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 setOpacity(m_series->opacity());
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 AbstractDomain* d = m_upper->domain();
             	d->setSize(domain()->size());
             	d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
             	m_upper->handleDomainUpdated();
                 if (m_lower) {
                     AbstractDomain* d = m_lower->domain();
                 	d->setSize(domain()->size());
                 	d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
                 	m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(m_upper->geometryPoints());
                     if (m_lower)
                         painter->drawPoints(m_lower->geometryPoints());
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->domain()->calculateDomainPoint(event->pos()));
                 ChartItem::mousePressEvent(event);
             }
             void AreaChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.cpp +1 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "abstractdomain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qarealegendmarker.h"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
                 An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
                 is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
                 which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                 In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
                 where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmlclass AreaSeries QAreaSeries
                 The following QML shows how to create a simple area chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image demos_qmlchart4.png
                 \endfloat
                 \clearfloat
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                 \qmlproperty real AreaSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \qmlsignal AreaSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal AreaSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries, lowerSeries, this), upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
-                if(d->m_upperSeries!=series){
+                if (d->m_upperSeries != series)
                 	d->m_upperSeries = series;
-                	//TODO:
             }
             QLineSeries *QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries *QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = brush.color() != d->m_brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
                   m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::initializeDomain()
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 QLineSeries *upperSeries = q->upperSeries();
                 QLineSeries *lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++) {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if (lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = new AreaChartItem(q,parent);
                 m_item.reset(area);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if (q->lowerSeries())
                     area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                 }else{
                     area->upperLineItem()->setAnimation(0);
                     if (q->lowerSeries())
                            area->lowerLineItem()->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<QLegendMarker*> list;
                 return list << new QAreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QAreaSeries);
                 QPen pen;
                 QBrush brush;
                 const QList<QGradient> gradients = theme->seriesGradients();
                 const QList<QColor> colors = theme->seriesColors();
                 if (forced || pen == m_pen) {
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || brush == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisx.cpp 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "chartcategoryaxisx_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item)
                 : HorizontalAxis(axis, item, true),
                   m_axis(axis)
             {
             }
             ChartCategoryAxisX::~ChartCategoryAxisX()
             {
             }
             QVector<qreal> ChartCategoryAxisX::calculateLayout() const
             {
                 int tickCount = m_axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 const QRectF &gridRect = gridGeometry();
                 qreal range  = max() - min();
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.width() / range;
                     for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             qreal x = (m_axis->startValue(m_axis->categoriesLabels().at(i)) - min()) * scale + gridRect.left();
                             points[i] = x;
                         } else {
                             qreal x = (m_axis->endValue(m_axis->categoriesLabels().at(i - 1)) - min())  * scale + gridRect.left();
                             points[i] = x;
                         }
                     }
                 }
                 return points;
             }
             void ChartCategoryAxisX::updateGeometry()
             {
                 //TODO: this is not optimal when many categories :( , create only visible lables
                 setLabels(m_axis->categoriesLabels() << "");
                 HorizontalAxis::updateGeometry();
             }
             void ChartCategoryAxisX::handleAxisUpdated()
             {
                 updateGeometry();
-                //TODO :: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF boundingRect = labelBoundingRect(fn, "...");
                     width = qMax(boundingRect.width(), base.width());
                     height = boundingRect.height() + labelPadding();
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     int labelHeight = 0;
                     foreach (const QString& s, ticksList) {
                         QRect rect = labelBoundingRect(fn, s);
                         labelHeight = qMax(rect.height(), labelHeight);
                         width += rect.width();
                     }
                     height = labelHeight + labelPadding();
                     height += base.height();
                     width = qMax(width, base.width());
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisy.cpp 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "chartcategoryaxisy_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis, QGraphicsItem* item)
                 : VerticalAxis(axis, item, true),
                   m_axis(axis)
             {
             }
             ChartCategoryAxisY::~ChartCategoryAxisY()
             {
             }
             QVector<qreal> ChartCategoryAxisY::calculateLayout() const
             {
                 int tickCount = m_axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 const QRectF &gridRect = gridGeometry();
                 qreal range = max() - min();
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.height() / range;
                     for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             qreal y = -(m_axis->startValue(m_axis->categoriesLabels().at(i)) - min()) * scale + gridRect.bottom();
                             points[i] = y;
                         } else {
                             qreal y = -(m_axis->endValue(m_axis->categoriesLabels().at(i - 1)) - min())  * scale + gridRect.bottom();
                             points[i] = y;
                         }
                     }
                 }
                 return points;
             }
             void ChartCategoryAxisY::updateGeometry()
             {
                 setLabels(m_axis->categoriesLabels() << "");
                 VerticalAxis::updateGeometry();
             }
             void ChartCategoryAxisY::handleAxisUpdated()
             {
                 updateGeometry();
-                //TODO:: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF boundingRect = labelBoundingRect(fn, "...");
                     width = boundingRect.width() + labelPadding();
                     width += base.width();
                     height = qMax(boundingRect.height(), base.height());
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     int labelWidth = 0;
                     foreach (const QString& s, ticksList) {
                         QRect rect = labelBoundingRect(fn, s);
                         labelWidth = qMax(rect.width(), labelWidth);
                         height += rect.height();
                     }
                     width = labelWidth + labelPadding() + 1;
                     width += base.width();
                     height = qMax(height, base.height());
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis.cpp +2 -8

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "abstractdomain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_labelsAngle(axis->labelsAngle()),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsSimpleTextItem(item)),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis),
                   m_titlePadding(3)
             {
                 Q_ASSERT(item);
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 handleVisibleChanged(m_axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents,true);
             }
             void ChartAxis::connectSlots()
             {
                 QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(gridVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleVisibleChanged(bool)),this,SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
             }
             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->childItems().size() == 0){
                     QGraphicsLineItem* arrow = new ArrowItem(this, this);
                     arrow->setPen(m_axis->linePen());
                     m_arrow->addToGroup(arrow);
                 }
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem* item = new QGraphicsLineItem(this);
                         item->setPen(m_axis->gridLinePen());
                         m_grid->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
                     arrow->setPen(m_axis->linePen());
                     QGraphicsLineItem* grid = new QGraphicsLineItem(this);
                     grid->setPen(m_axis->gridLinePen());
                     QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
                     label->setFont(m_axis->labelsFont());
                     label->setPen(m_axis->labelsPen());
                     label->setBrush(m_axis->labelsBrush());
                     label->setRotation(m_labelsAngle);
                     m_arrow->addToGroup(arrow);
                     m_grid->addToGroup(grid);
                     m_labels->addToGroup(label);
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(m_axis->shadesPen());
                         shades->setBrush(m_axis->shadesBrush());
                         m_shades->addToGroup(shades);
                     }
                 }
             }
             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 (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::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             void ChartAxis::setTitlePadding(int padding)
             {
                 m_titlePadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() ||  qFuzzyCompare(min(),max());
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             qreal ChartAxis::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxis::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QFont ChartAxis::font() const
             {
                 return m_axis->labelsFont();
             }
             QFont ChartAxis::titleFont() const
             {
                 return m_axis->titleFont();
             }
             QString ChartAxis::titleText() const
             {
                 return m_axis->titleText();
             }
             void ChartAxis::axisSelected()
             {
                 emit clicked();
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_axis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_axis->alignment();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             //handlers
             void ChartAxis::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxis::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxis::handleLabelsVisibleChanged(bool visible)
             {
                 m_labels->setVisible(visible);
             }
             void ChartAxis::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxis::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::handleLabelsPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                 static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setText(title);
             }
             void ChartAxis::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::handleTitleFontChanged(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if(!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 }else {
                     m_grid->setVisible(m_axis->isGridLineVisible());
                     m_arrow->setVisible(m_axis->isLineVisible());
                     m_shades->setVisible(m_axis->shadesVisible());
                     m_labels->setVisible(m_axis->labelsVisible());
                     m_title->setVisible(m_axis->isTitleVisible());
                 }
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         //we don't want to call invalidate on layout, since it will change minimum size of component,
                         //which we would like to avoid since it causes nasty flips when scrolling or zooming,
                         //instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             //helpers
             QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
             {
-                //TODO: Q_ASSERT(m_max > m_min);
-                //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
-                if(max <= min || ticks < 1){
+                if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
             {
             //    Q_ASSERT(m_max > m_min);
                 //    Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = 0;
                 if (ticks > 1)
                     n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
             {
-                //TODO: Q_ASSERT(m_max > m_min);
-                //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
-                if(max <= min || ticks < 1) {
+                if (max <= min || ticks < 1) {
                     return labels;
                 }
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             QRect ChartAxis::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
             {
                 QRect boundingRect = fn.boundingRect(label);
                 // Take label rotation into account
                 if (m_labelsAngle) {
                     QTransform transform;
                     transform.rotate(m_labelsAngle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +2 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 There is only one x Axis visible at the time, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass AbstractAxis QAbstractAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis visible at the time, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the series object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
                 \value AxisTypeLogValue
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::linePen
               The pen of the line.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::labelsPen
               The pen of the labels.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::gridLinePen
               The pen of the grid line.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesPen
               The pen of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::shadesBrush
               The brush of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \qmlproperty bool AbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \property QAbstractAxis::titleText
               The title of the axis. Empty by default.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default.
             */
             /*!
               \property QAbstractAxis::titlePen
               The pen of the title text.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
             */
             /*!
               \qmlproperty Qt.Orientation AbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a Chart/Series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Either Qt::AlignLeft or Qt::AlignBottom.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Either Qt.AlignLeft or Qt.AlignBottom.
             */
             /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::linePenChanged(const QPen& pen)
               The pen of the line of the axis has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsFontChanged(const QFont& font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::labelsPenChanged(const QPen& pen)
               The pen of the axis labels has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
               The brush of the axis labels has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::labelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridLinePenChanged(const QPen& pen)
               The pen of the grid line has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::titleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::titleTextChanged(const QString& text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleTextChanged(String text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \fn void QAbstractAxis::titlePenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
               The brush of the axis title has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::titleFontChanged(const QFont& font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
               The brush of the axis shades has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 return d_ptr->m_axisPen;
             }
-            //TODO: remove me
+            //TODO: remove me 2.0
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit gridLinePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit labelsBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit labelsFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
-            //TODO: remove me
+            //TODO: remove me 2.0
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit titleVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isTitleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a pen used to draw title.
             */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to title.
             */
             QPen QAbstractAxis::titlePen() const
             {
                 return d_ptr->m_titlePen;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush  QAbstractAxis::titleBrush() const
             {
                 return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit shadesPenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit shadesBrushChanged(brush);
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
             	QPen p = d_ptr->m_shadesPen;
             	if (p.color() != color) {
             		p.setColor(color);
             		setShadesPen(p);
             		emit shadesColorChanged(color);
             	}
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             // NOTE: should have const but it breaks BC:
             // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
             Qt::Orientation QAbstractAxis::orientation()
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_alignment(0),
                   m_orientation(Qt::Orientation(0)),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_gridLineVisible(true),
                   m_labelsVisible(true),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_shadesVisible(false),
                   m_shadesBrush(Qt::SolidPattern),
                   m_shadesOpacity(1.0),
                   m_dirty(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 bool axisX = m_orientation == Qt::Horizontal;
                 //TODO: introduce axis brush
                 if (m_visible) {
                     if (m_arrowVisible) {
                         if (forced || pen == m_axisPen) {
                             q_ptr->setLinePen(theme->axisLinePen());
                         }
                     }
                     if (m_gridLineVisible) {
                         if (forced || pen == m_gridLinePen) {
                             q_ptr->setGridLinePen(theme->girdLinePen());
                         }
                     }
                     if (m_labelsVisible) {
                         if (forced || brush == m_labelsBrush){
                             q_ptr->setLabelsBrush(theme->labelBrush());
                         }
                         if (forced || pen == m_labelsPen){
                             q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
                         }
                         if (forced || font == m_labelsFont){
                             q_ptr->setLabelsFont(theme->labelFont());
                         }
                     }
                     if (m_titleVisible) {
                         if (forced || brush == m_titleBrush){
                             q_ptr->setTitleBrush(theme->labelBrush());
                         }
                         if (forced || pen == m_titlePen){
                             q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
                         }
-                        //TODO: discuss with Tero
                         if (forced || font == m_titleFont){
                             QFont font(m_labelsFont);
                             font.setBold(true);
                             q_ptr->setTitleFont(font);
                         }
                     }
                     if (forced || m_shadesVisible) {
                         if (forced || brush == m_shadesBrush){
                             q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                         }
                         if (forced || pen == m_shadesPen){
                             q_ptr->setShadesPen(theme->backgroundShadesPen());
                         }
                         if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                              q_ptr->setShadesVisible(true);
                         }
                     }
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxis* axis = m_item.data();
                 Q_ASSERT(axis);
                 if(options.testFlag(QChart::GridAxisAnimations)) {
                     axis->setAnimation(new AxisAnimation(axis));
                 }else{
                     axis->setAnimation(0);
                 }
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             #include <QVariant>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAbstractAxis : public QObject
             {
                 Q_OBJECT
                 //visibility
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 //arrow
                 Q_PROPERTY(bool lineVisible READ isLineVisible WRITE setLineVisible NOTIFY lineVisibleChanged)
                 Q_PROPERTY(QPen linePen READ linePen WRITE setLinePen NOTIFY linePenChanged)
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QPen labelsPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
                 Q_PROPERTY(QBrush labelsBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
-                //TODO: fix labels angles to work with layout
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(QPen gridLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
                 Q_PROPERTY(QPen shadesPen READ shadesPen WRITE setShadesPen NOTIFY shadesPenChanged)
                 Q_PROPERTY(QBrush shadesBrush READ shadesBrush WRITE setShadesBrush NOTIFY shadesBrushChanged)
                 //title
                 Q_PROPERTY(QString titleText READ titleText WRITE setTitleText NOTIFY titleTextChanged)
                 Q_PROPERTY(QPen titlePen READ titlePen WRITE setTitlePen NOTIFY titlePenChanged)
                 Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ isTitleVisible WRITE setTitleVisible NOTIFY titleVisibleChanged)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont NOTIFY titleFontChanged)
                 //orientation
                 Q_PROPERTY(Qt::Orientation orientation READ orientation)
                 //aligment
                 Q_PROPERTY(Qt::Alignment alignment READ alignment)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
                     AxisTypeCategory = 0x3,
                     AxisTypeDateTime = 0x4,
                     AxisTypeLogValue = 0x5
                 };
                 Q_DECLARE_FLAGS(AxisTypes, AxisType)
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //visibility handling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
                 void show();
                 void hide();
                 //arrow handling
                 bool isLineVisible() const;
                 void setLineVisible(bool visible = true);
                 void setLinePen(const QPen &pen);
                 QPen linePen() const;
                 void setLinePenColor(QColor color);
                 QColor linePenColor() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() const;
                 //title handling
                 bool isTitleVisible() const;
                 void setTitleVisible(bool visible = true);
                 void setTitlePen(const QPen &pen);
                 QPen titlePen() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleText(const QString &title);
                 QString titleText() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
-                Qt::Orientation orientation(); //TODO: missing const <- BC
+                Qt::Orientation orientation(); //TODO: missing const <- BC (2.0)
                 Qt::Alignment alignment() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void linePenChanged(const QPen& pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void labelsPenChanged(const QPen& pen);
                 void labelsBrushChanged(const QBrush& brush);
                 void labelsFontChanged(const QFont& pen);
                 void labelsAngleChanged(int angle);
                 void gridLinePenChanged(const QPen& pen);
                 void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void titleTextChanged(const QString& title);
                 void titlePenChanged(const QPen& pen);
                 void titleBrushChanged(const QBrush& brush);
                 void titleVisibleChanged(bool visible);
                 void titleFontChanged(const QFont& font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
                 void shadesPenChanged(const QPen& pen);
                 void shadesBrushChanged(const QBrush& brush);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis)
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class AbstractDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

src/axis/valueaxis/qvalueaxis.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 QVALUEAXIS_H
             #define QVALUEAXIS_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QValueAxis : public QAbstractAxis
             {
                 Q_OBJECT
                 Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount NOTIFY tickCountChanged)
                 Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled)
                 Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
                 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
                 Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat NOTIFY labelFormatChanged)
             public:
                 explicit QValueAxis(QObject *parent = 0);
                 ~QValueAxis();
             protected:
                 QValueAxis(QValueAxisPrivate &d, QObject *parent = 0);
             public:
                 AxisType type() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTickCount(int count);
                 int tickCount() const;
                 void setLabelFormat(const QString &format);
                 QString labelFormat() const;
-                //TODO: depreciated !
+                //TODO: deprecated! (2.0)
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
             public Q_SLOTS:
                 void applyNiceNumbers();
             Q_SIGNALS:
                 void minChanged(qreal min);
                 void maxChanged(qreal max);
                 void rangeChanged(qreal min, qreal max);
                 void tickCountChanged(int tickCount);
                 void labelFormatChanged(const QString &format);
             private:
                 Q_DECLARE_PRIVATE(QValueAxis)
                 Q_DISABLE_COPY(QValueAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUEAXIS_H

src/axis/valueaxis/qvalueaxis_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QVALUEAXIS_P_H
             #define QVALUEAXIS_P_H
             #include "qvalueaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
                 QValueAxisPrivate(QValueAxis *q);
                 ~QValueAxisPrivate();
             public:
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeDomain(AbstractDomain *domain);
                 qreal min() { return m_min; };
                 qreal max() { return m_max; };
                 void setRange(qreal min,qreal max);
             protected:
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             private:
                 qreal m_min;
                 qreal m_max;
                 int m_tickCount;
                 QString m_format;
                 bool m_applying;
-                bool m_niceNumbersEnabled; //TODO: this depreciated
+                bool m_niceNumbersEnabled; //TODO: this deprecated (2.0)
                 Q_DECLARE_PUBLIC(QValueAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUEAXIS_P_H

src/chartlayout.cpp 0 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "chartlayout_p.h"
             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
             #include "chartaxis_p.h"
             #include "charttitle_p.h"
             #include "chartbackground_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             static const qreal maxAxisPortion = 0.4;
             ChartLayout::ChartLayout(ChartPresenter *presenter)
                 : m_presenter(presenter),
                   m_margins(20, 20, 20, 20),
                   m_minChartRect(0, 0, 200, 200)
             {
             }
             ChartLayout::~ChartLayout()
             {
             }
             void ChartLayout::setGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QList<ChartAxis *> axes = m_presenter->axisItems();
                 ChartTitle *title = m_presenter->titleElement();
                 QLegend *legend = m_presenter->legend();
                 ChartBackground *background = m_presenter->backgroundElement();
                 QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
                 contentGeometry = calculateContentGeometry(contentGeometry);
                 if (title && title->isVisible())
                     contentGeometry = calculateTitleGeometry(contentGeometry, title);
                 if (legend->isAttachedToChart() && legend->isVisible())
                     contentGeometry = calculateLegendGeometry(contentGeometry, legend);
                 contentGeometry = calculateAxisGeometry(contentGeometry, axes);
                 m_presenter->setGeometry(contentGeometry);
                 QGraphicsLayout::setGeometry(rect);
             }
             QRectF ChartLayout::calculateContentGeometry(const QRectF &geometry) const
             {
                 return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
             }
             QRectF ChartLayout::calculateContentMinimum(const QRectF &minimum) const
             {
                 return  minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
             }
             QRectF ChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
             {
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
                 if (background)
                     background->setRect(backgroundGeometry);
                 return backgroundGeometry;
             }
             QRectF ChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
             {
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 return minimum.adjusted(0, 0, left + right, top + bottom);
             }
             QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
             {
                 QSizeF left(0,0);
                 QSizeF minLeft(0,0);
                 QSizeF right(0,0);
                 QSizeF minRight(0,0);
                 QSizeF bottom(0,0);
                 QSizeF minBottom(0,0);
                 QSizeF top(0,0);
                 QSizeF minTop(0,0);
                 int leftCount = 0;
                 int rightCount = 0;
                 int topCount = 0;
                 int bottomCount = 0;
                 foreach (ChartAxis *axis , axes) {
                     if (!axis->isVisible())
                         continue;
                     QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
                     //this is used to get single thick font size
                     QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize);
                     switch (axis->alignment()) {
                     case Qt::AlignLeft:
                        left.setWidth(left.width()+size.width());
                        left.setHeight(qMax(left.height(),size.height()));
                        minLeft.setWidth(minLeft.width()+minSize.width());
                        minLeft.setHeight(qMax(minLeft.height(),minSize.height()));
                        leftCount++;
                        break;
                     case Qt::AlignRight:
                         right.setWidth(right.width()+size.width());
                         right.setHeight(qMax(right.height(),size.height()));
                         minRight.setWidth(minRight.width()+minSize.width());
                         minRight.setHeight(qMax(minRight.height(),minSize.height()));
                         rightCount++;
                         break;
                     case Qt::AlignTop:
                         top.setWidth(qMax(top.width(),size.width()));
                         top.setHeight(top.height()+size.height());
                         minTop.setWidth(qMax(minTop.width(),minSize.width()));
                         minTop.setHeight(minTop.height()+minSize.height());
                         topCount++;
                         break;
                     case Qt::AlignBottom:
                         bottom.setWidth(qMax(bottom.width(), size.width()));
                         bottom.setHeight(bottom.height() + size.height());
                         minBottom.setWidth(qMax(minBottom.width(),minSize.width()));
                         minBottom.setHeight(minBottom.height() + minSize.height());
                         bottomCount++;
                         break;
                     default:
                         qWarning()<<"Axis is without alignment !";
                         break;
                     }
                 }
                 int totalVerticalAxes = leftCount + rightCount;
                 qreal leftSqueezeRatio = 1.0;
                 qreal rightSqueezeRatio = 1.0;
                 qreal vratio = 0;
                 if (totalVerticalAxes > 0)
                     vratio = (maxAxisPortion * geometry.width()) / totalVerticalAxes;
                 if (leftCount > 0) {
                     int maxWidth = vratio * leftCount;
                     if (left.width() > maxWidth) {
                         leftSqueezeRatio = maxWidth / left.width();
                         left.setWidth(maxWidth);
                     }
                 }
                 if (rightCount > 0) {
                     int maxWidth = vratio * rightCount;
                     if (right.width() > maxWidth) {
                         rightSqueezeRatio = maxWidth / right.width();
                         right.setWidth(maxWidth);
                     }
                 }
                 int totalHorizontalAxes = topCount + bottomCount;
                 qreal topSqueezeRatio = 1.0;
                 qreal bottomSqueezeRatio = 1.0;
                 qreal hratio = 0;
                 if (totalHorizontalAxes > 0)
                     hratio = (maxAxisPortion * geometry.height()) / totalHorizontalAxes;
                 if (topCount > 0) {
                     int maxHeight = hratio * topCount;
                     if (top.height() > maxHeight) {
                         topSqueezeRatio = maxHeight / top.height();
                         top.setHeight(maxHeight);
                     }
                 }
                 if (bottomCount > 0) {
                     int maxHeight = hratio * bottomCount;
                     if (bottom.height() > maxHeight) {
                         bottomSqueezeRatio = maxHeight / bottom.height();
                         bottom.setHeight(maxHeight);
                     }
                 }
                 qreal minHeight = qMax(minLeft.height(),minRight.height()) + 1;
                 qreal minWidth = qMax(minTop.width(),minBottom.width()) + 1;
                 QRectF chartRect = geometry.adjusted(qMax(left.width(),minWidth/2), qMax(top.height(), minHeight/2),-qMax(right.width(),minWidth/2),-qMax(bottom.height(),minHeight/2));
                 qreal leftOffset = 0;
                 qreal rightOffset = 0;
                 qreal topOffset = 0;
                 qreal bottomOffset = 0;
                 foreach(ChartElement *axisElement , axes) {
-                    //TODO fixme
                     ChartAxis* axis = qobject_cast<ChartAxis*>(axisElement);
                     if (!axis->isVisible())
                         continue;
                     QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
                     switch(axis->alignment()){
                     case Qt::AlignLeft:{
                         qreal width = size.width();
                         if (leftSqueezeRatio < 1.0)
                             width *= leftSqueezeRatio;
                         leftOffset+=width;
                         axis->setGeometry(QRect(chartRect.left()-leftOffset, geometry.top(),width, geometry.bottom()),chartRect);
                         break;
                     }
                     case Qt::AlignRight:{
                         qreal width = size.width();
                         if (rightSqueezeRatio < 1.0)
                             width *= rightSqueezeRatio;
                         axis->setGeometry(QRect(chartRect.right()+rightOffset,geometry.top(),width,geometry.bottom()),chartRect);
                         rightOffset+=width;
                         break;
                     }
                     case Qt::AlignTop: {
                         qreal height = size.height();
                         if (topSqueezeRatio < 1.0)
                             height *= topSqueezeRatio;
                         axis->setGeometry(QRect(geometry.left(), chartRect.top() - topOffset - height, geometry.width(), height), chartRect);
                         topOffset += height;
                         break;
                     }
                     case Qt::AlignBottom:
                         qreal height = size.height();
                         if (bottomSqueezeRatio < 1.0)
                             height *= bottomSqueezeRatio;
                         axis->setGeometry(QRect(geometry.left(), chartRect.bottom() + bottomOffset, geometry.width(), height), chartRect);
                         bottomOffset += height;
                         break;
                     }
                 }
                 return chartRect;
             }
             QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const
             {
                 QSizeF left;
                 QSizeF right;
                 QSizeF bottom;
                 QSizeF top;
                 foreach (ChartAxis *axis, axes) {
                     QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
                     if (!axis->isVisible())
                         continue;
                     switch (axis->alignment()) {
                     case Qt::AlignLeft:
                         left.setWidth(left.width() + size.width());
                         left.setHeight(qMax(left.height() * 2, size.height()));
                         break;
                     case Qt::AlignRight:
                         right.setWidth(right.width() + size.width());
                         right.setHeight(qMax(right.height() * 2, size.height()));
                         break;
                     case Qt::AlignTop:
                         top.setWidth(qMax(top.width(), size.width()));
                         top.setHeight(top.height() + size.height());
                         break;
                     case Qt::AlignBottom:
                         bottom.setWidth(qMax(bottom.width(), size.width()));
                         bottom.setHeight(bottom.height() + size.height());
                         break;
                     }
                 }
                 return minimum.adjusted(0, 0, left.width() + right.width() + qMax(top.width(), bottom.width()), top.height() + bottom.height() + qMax(left.height(), right.height()));
             }
             QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
                 QRectF legendRect;
                 QRectF result;
                 switch (legend->alignment()) {
                 case Qt::AlignTop: {
                     legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, legendRect.height(), 0, 0);
                     break;
                 }
                 case Qt::AlignBottom: {
                     legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, 0, 0, -legendRect.height());
                     break;
                 }
                 case Qt::AlignLeft: {
                     qreal width = qMin(size.width(), geometry.width() * maxAxisPortion);
                     legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(width, 0, 0, 0);
                     break;
                 }
                 case Qt::AlignRight: {
                     qreal width = qMin(size.width(), geometry.width() * maxAxisPortion);
                     legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(0, 0, -width, 0);
                     break;
                 }
                 default: {
                     legendRect = QRectF(0, 0, 0, 0);
                     result = geometry;
                     break;
                 }
                 }
                 legend->setGeometry(legendRect);
                 return result;
             }
             QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
                 return geometry.adjusted(0, 0, minSize.width(), minSize.height());
             }
             QRectF ChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
             {
                 title->setGeometry(geometry);
                 QPointF center = geometry.center() - title->boundingRect().center();
                 title->setPos(center.x(),title->pos().y());
                 return geometry.adjusted(0,title->boundingRect().height()+1,0,0);
             }
             QRectF ChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
             {
                 QSizeF min = title->sizeHint(Qt::MinimumSize);
                 return  minimum.adjusted(0, 0, min.width(), min.height());
             }
             QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 if (which == Qt::MinimumSize) {
                     QList<ChartAxis *> axes = m_presenter->axisItems();
                     ChartTitle *title = m_presenter->titleElement();
                     QLegend *legend = m_presenter->legend();
                     QRectF minimumRect(0, 0, 0, 0);
                     minimumRect = calculateBackgroundMinimum(minimumRect);
                     minimumRect = calculateContentMinimum(minimumRect);
                     minimumRect = calculateTitleMinimum(minimumRect, title);
                     minimumRect = calculateLegendMinimum(minimumRect, legend);
                     minimumRect = calculateAxisMinimum(minimumRect, axes);
                     return  minimumRect.united(m_minChartRect).size().toSize();
                 }
                 return QSize(-1, -1);
             }
             void ChartLayout::setMargins(const QMargins &margins)
             {
                 if (m_margins != margins) {
                     m_margins = margins;
                     updateGeometry();
                 }
             }
             QMargins ChartLayout::margins() const
             {
                 return m_margins;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
-            #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
+            #include "qchart.h" //because of QChart::ChartThemeId
             #include <QRectF>
             #include <QMargins>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxis;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class ChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue ,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 ChartTitle *titleElement();
                 QList<ChartAxis *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 ChartItem* chartElement(QAbstractSeries* series) const;
                 ChartAxis* chartElement(QAbstractAxis* axis) const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void startAnimation(ChartAnimation *animation);
                 //TODO refactor
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 ChartLayout *layout();
             private:
                 void createBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void animationsFinished();
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxis *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation *> m_animations;
                 ChartLayout *m_layout;
                 ChartBackground *m_background;
                 ChartTitle *m_title;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/qabstractseries.cpp 0 -5

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmlclass AbstractSeries
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for QXYSeries.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for QXYSeries.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Sets the visibility of series to \a visible
             */
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             /*!
                 Returns the visibility of series
             */
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
-            //void QAbstractSeries::adjustView()
-            //{
-            //    //TODO:
-            //}
             /*!
                 \brief Sets the visibility of the series to true
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_UNUSED(options);
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +1 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "chartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::margins
              Minimum between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              Note: changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this))
             {
                 d_ptr->m_legend = new LegendScroller(this);
                 setTheme(QChart::ChartThemeLight);
-                //TODO: what is that ?
-                //connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
                 setLayout(d_ptr->m_presenter->layout());
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of the object.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              \sa removeSeries(), removeAllSeries()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                     removeSeries(s);
                     delete s;
                 }
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 d_ptr->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns the pointer to the y axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns the axes added for the \a series with \a orientation. If no series is provided, then all axes with the
              specified orientation are returned.
              \sa addAxis(), createDefaultAxes()
              */
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 if (series) {
                     foreach (QAbstractAxis *axis, series->attachedAxes()){
                         if (orientation.testFlag(axis->orientation()))
                             result << axis;
                     }
                 } else {
                     foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                         if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                             result << axis;
                     }
                 }
                 return result;
             }
             /*!
              NOTICE: This function has to be called after series has been added to the chart if no customized axes are set to the chart. Otherwise axisX(), axisY() calls return NULL.
              Creates the axes for the chart based on the series that has already been added to the chart.
             \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
                  \endtable
              If there are several QXYSeries derived series added to the chart and no other series type has been added then only one pair of axes is created.
              If there are sevaral series added of different types then each series gets its own axes pair.
              NOTICE: if there is more than one x and y axes created then no axis is drawn by default and one needs to choose explicitly which axis should be shown.
              Axis specifix to the series can be later obtained from the chart by providing the series as the parameter of axisX(), axisY() function calls.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), setAxisX(), setAxisY()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
               Deprecated. Use setMargins().
             */
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
                 Deprecated. Use margins().
              */
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
             */
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             /*!
                 Returns the the rect within which the drawing of the chart is done.
                 It does not include the area defines by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
             ///*!
             //    TODO: Dummy.
-            //    Adjest the ranges of the axes so that all the data of the specified \a series is visible
+            //    Adjust the ranges of the axes so that all the data of the specified \a series is visible
             // */
             //void QChart::adjustViewToSeries(QAbstractSeries* series)
             //{
             //    //
             //}
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->scroll(dx,dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
               Returns all the series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
             */
             void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Horizontal,series);
                 foreach(QAbstractAxis* a, list){
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if(!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis,Qt::AlignBottom);
                 d_ptr->m_dataset->attachAxis(series,axis);
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisX(), createDefaultAxes()
             */
             void QChart::setAxisY(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical,series);
                 foreach(QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if(!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis,Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series,axis);
             }
             /*!
               Adds \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
               \sa removeAxis(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::addAxis(QAbstractAxis *axis, Qt::Alignment alignment)
             {
                 d_ptr->m_dataset->addAxis(axis, alignment);
             }
             /*!
               Removes \a axis from the chart. The ownership is returned to the caller.
               \sa addAxis(), createDefaultAxes(), QAbstractSeries::detachAxis()
             */
             void QChart::removeAxis(QAbstractAxis *axis)
             {
                 d_ptr->m_dataset->removeAxis(axis);
             }
             /*!
               Returns the value in the \a series domain that coresponds to the charts widget point defines by \a position.
             */
             QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToValue(position, series);
             }
             /*!
               Returns the position on the charts widget that coresponds to the \a value in the \a series domain.
             */
             QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToPosition(value, series);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q):
                 q_ptr(q),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q)),
                 m_themeManager(new ChartThemeManager(q))
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qabstractaxis/tst_qabstractaxis.cpp 0 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "tst_qabstractaxis.h"
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(Qt::Orientation)
             void tst_QAbstractAxis::initTestCase()
             {
             }
             void tst_QAbstractAxis::cleanupTestCase()
             {
             }
             void tst_QAbstractAxis::init(QAbstractAxis* axis, QAbstractSeries* series)
             {
                 m_axis = axis;
                 m_series = series;
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QAbstractAxis::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
                 m_axis = 0;
             }
             void tst_QAbstractAxis::qabstractaxis()
             {
                 QCOMPARE(m_axis->linePen(), QPen());
-                //TODO QCOMPARE(m_axis->axisPenColor(), QColor());
                 QCOMPARE(m_axis->gridLinePen(), QPen());
                 QCOMPARE(m_axis->isLineVisible(), true);
                 QCOMPARE(m_axis->isGridLineVisible(), true);
                 QCOMPARE(m_axis->isVisible(), true);
                 QCOMPARE(m_axis->labelsAngle(), 0);
                 QCOMPARE(m_axis->labelsBrush(), QBrush());
-                //TODO QCOMPARE(m_axis->labelsColor(), QColor());
                 QCOMPARE(m_axis->labelsFont(), QFont());
                 QCOMPARE(m_axis->labelsPen(), QPen());
                 QCOMPARE(m_axis->labelsVisible(), true);
                 QCOMPARE(m_axis->orientation(), Qt::Orientation(0));
                 m_axis->setLineVisible(false);
                 m_axis->setLinePen(QPen());
                 m_axis->setLinePenColor(QColor());
                 m_axis->setGridLinePen(QPen());
                 m_axis->setGridLineVisible(false);
                 m_axis->setLabelsAngle(-1);
                 m_axis->setLabelsBrush(QBrush());
                 m_axis->setLabelsColor(QColor());
                 m_axis->setLabelsFont(QFont());
                 m_axis->setLabelsPen(QPen());
                 m_axis->setLabelsVisible(false);
                 m_axis->setMax(QVariant());
                 m_axis->setMin(QVariant());
                 m_axis->setRange(QVariant(), QVariant());
                 m_axis->setShadesBorderColor(QColor());
                 m_axis->setShadesBrush(QBrush());
                 m_axis->setShadesColor(QColor());
                 m_axis->setShadesPen(QPen());
                 m_axis->setShadesVisible(false);
                 m_axis->setVisible(false);
-                //TODO QCOMPARE(m_axis->shadesBorderColor(), QColor());
                 //TODO QCOMPARE(m_axis->shadesBrush(), QBrush());
-                //TODO QCOMPARE(m_axis->shadesColor(), QColor());
                 QCOMPARE(m_axis->shadesPen(), QPen());
                 QCOMPARE(m_axis->shadesVisible(), false);
                 m_axis->show();
                 m_axis->hide();
             }
             void tst_QAbstractAxis::axisPen_data()
             {
                 QTest::addColumn<QPen>("axisPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::axisPen()
             {
                 QFETCH(QPen, axisPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLinePen(axisPen);
                 QCOMPARE(m_axis->linePen(), axisPen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->axisPen(), axisPen);
             }
             void tst_QAbstractAxis::axisPenColor_data()
             {
             }
             void tst_QAbstractAxis::axisPenColor()
             {
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 QSKIP("Test is not implemented. This is deprecated function");
             #else
                 QSKIP("Test is not implemented. This is deprecated function", SkipAll);
             #endif
             }
             void tst_QAbstractAxis::gridLinePen_data()
             {
                 QTest::addColumn<QPen>("gridLinePen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::gridLinePen()
             {
                 QFETCH(QPen, gridLinePen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setGridLinePen(gridLinePen);
                 QCOMPARE(m_axis->gridLinePen(), gridLinePen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->gridLinePen(), gridLinePen);
             }
             void tst_QAbstractAxis::lineVisible_data()
             {
                 QTest::addColumn<bool>("lineVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::lineVisible()
             {
                 QFETCH(bool, lineVisible);
                 m_axis->setLineVisible(!lineVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLineVisible(lineVisible);
                 QCOMPARE(m_axis->isLineVisible(), lineVisible);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isLineVisible(), lineVisible);
             }
             void tst_QAbstractAxis::gridLineVisible_data()
             {
                 QTest::addColumn<bool>("gridLineVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::gridLineVisible()
             {
                 QFETCH(bool, gridLineVisible);
                 m_axis->setGridLineVisible(!gridLineVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setGridLineVisible(gridLineVisible);
                 QCOMPARE(m_axis->isGridLineVisible(), gridLineVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isGridLineVisible(), gridLineVisible);
             }
             void tst_QAbstractAxis::visible_data()
             {
                 QTest::addColumn<bool>("visible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::visible()
             {
                 QFETCH(bool, visible);
                 m_axis->setVisible(!visible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setVisible(visible);
                 QCOMPARE(m_axis->isVisible(), visible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->isVisible(), visible);
             }
             void tst_QAbstractAxis::labelsAngle_data()
             {
                 QTest::addColumn<int>("labelsAngle");
                 QTest::newRow("0") << 0;
                 QTest::newRow("45") << 45;
                 QTest::newRow("90") << 90;
             }
             void tst_QAbstractAxis::labelsAngle()
             {
                 QFETCH(int, labelsAngle);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLabelsAngle(labelsAngle);
                 QCOMPARE(m_axis->labelsAngle(), labelsAngle);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsAngle(), labelsAngle);
             }
             void tst_QAbstractAxis::labelsBrush_data()
             {
                 QTest::addColumn<QBrush>("labelsBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QAbstractAxis::labelsBrush()
             {
                 QFETCH(QBrush, labelsBrush);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLabelsBrush(labelsBrush);
                 QCOMPARE(m_axis->labelsBrush(), labelsBrush);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 //TODO QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsBrush(), labelsBrush);
             }
             void tst_QAbstractAxis::labelsColor_data()
             {
             }
             void tst_QAbstractAxis::labelsColor()
             {
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 QSKIP("Test is not implemented. This is deprecated function");
             #else
                 QSKIP("Test is not implemented. This is deprecated function", SkipAll);
             #endif
             }
             void tst_QAbstractAxis::labelsFont_data()
             {
                 QTest::addColumn<QFont>("labelsFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("serif") << QFont("SansSerif");
             }
             void tst_QAbstractAxis::labelsFont()
             {
                 QFETCH(QFont, labelsFont);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLabelsFont(labelsFont);
                 QCOMPARE(m_axis->labelsFont(), labelsFont);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsFont(), labelsFont);
             }
             void tst_QAbstractAxis::labelsPen_data()
             {
                 QTest::addColumn<QPen>("labelsPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::labelsPen()
             {
                 QFETCH(QPen, labelsPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLabelsPen(labelsPen);
                 QCOMPARE(m_axis->labelsPen(), labelsPen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 //TODO QCOMPARE(m_axis->labelsPen(), labelsPen);
             }
             void tst_QAbstractAxis::labelsVisible_data()
             {
                 QTest::addColumn<bool>("labelsVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::labelsVisible()
             {
                 QFETCH(bool, labelsVisible);
                 m_axis->setLabelsVisible(!labelsVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setLabelsVisible(labelsVisible);
                 QCOMPARE(m_axis->labelsVisible(), labelsVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 1);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->labelsVisible(), labelsVisible);
             }
             void tst_QAbstractAxis::orientation_data()
             {
                 QTest::addColumn<Qt::Orientation>("orientation");
                 QTest::newRow("Vertical") << Qt::Vertical;
                 QTest::newRow("Horizontal") << Qt::Horizontal;
             }
             void tst_QAbstractAxis::orientation()
             {
                 QFETCH(Qt::Orientation, orientation);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 if(orientation==Qt::Vertical){
                     m_chart->setAxisY(m_axis,m_series);
                 }else{
                     m_chart->setAxisX(m_axis,m_series);
                 }
                 QCOMPARE(m_axis->orientation(), orientation);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->orientation(), orientation);
             }
             void tst_QAbstractAxis::setMax_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("max");
                 QTest::newRow("something") << QVariant("something");
                 QTest::newRow("1.0") << QVariant(1.0);
             }
             void tst_QAbstractAxis::setMax()
             {
                 QFETCH(QVariant, max);
                 m_axis->setMax(max);
             }
             void tst_QAbstractAxis::setMin_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("min");
                 QTest::newRow("something") << QVariant("something");
                 QTest::newRow("1.0") << QVariant(1.0);
             }
             // public void setMin(QVariant const& min)
             void tst_QAbstractAxis::setMin()
             {
                 QFETCH(QVariant, min);
                 m_axis->setMin(min);
             }
             void tst_QAbstractAxis::setRange_data()
             {
                 //just check if it does not crash
                 QTest::addColumn<QVariant>("min");
                 QTest::addColumn<QVariant>("max");
                 QTest::newRow("something") << QVariant("something0") << QVariant("something1");
                 QTest::newRow("-1 1") << QVariant(-1.0) << QVariant(1.0);
             }
             // public void setRange(QVariant const& min, QVariant const& max)
             void tst_QAbstractAxis::setRange()
             {
                 QFETCH(QVariant, min);
                 QFETCH(QVariant, max);
                 m_axis->setRange(min,max);
             }
             void tst_QAbstractAxis::shadesBorderColor_data()
             {
             }
             void tst_QAbstractAxis::shadesBorderColor()
             {
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 QSKIP("Test is not implemented. This is deprecated function");
             #else
                 QSKIP("Test is not implemented. This is deprecated function", SkipAll);
             #endif
             }
             void tst_QAbstractAxis::shadesBrush_data()
             {
                 QTest::addColumn<QBrush>("shadesBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QAbstractAxis::shadesBrush()
             {
                 QFETCH(QBrush, shadesBrush);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setShadesBrush(shadesBrush);
                 QCOMPARE(m_axis->shadesBrush(), shadesBrush);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 //TODO QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesBrush(), shadesBrush);
             }
             void tst_QAbstractAxis::shadesColor_data()
             {
             }
             // public QColor shadesColor() const
             void tst_QAbstractAxis::shadesColor()
             {
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 QSKIP("Test is not implemented. This is deprecated function");
             #else
                 QSKIP("Test is not implemented. This is deprecated function", SkipAll);
             #endif
             }
             void tst_QAbstractAxis::shadesPen_data()
             {
                 QTest::addColumn<QPen>("shadesPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QAbstractAxis::shadesPen()
             {
                 QFETCH(QPen, shadesPen);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setShadesPen(shadesPen);
                 QCOMPARE(m_axis->shadesPen(), shadesPen);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesPen(), shadesPen);
             }
             void tst_QAbstractAxis::shadesVisible_data()
             {
                 QTest::addColumn<bool>("shadesVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QAbstractAxis::shadesVisible()
             {
                 QFETCH(bool, shadesVisible);
                 m_axis->setShadesVisible(!shadesVisible);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->setShadesVisible(shadesVisible);
                 QCOMPARE(m_axis->shadesVisible(), shadesVisible);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 1);
                 QCOMPARE(spy8.count(), 0);
                 m_chart->setAxisX(m_axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_axis->shadesVisible(), shadesVisible);
             }
             void tst_QAbstractAxis::show_data()
             {
             }
             void tst_QAbstractAxis::show()
             {
                 m_axis->hide();
                 QCOMPARE(m_axis->isVisible(), false);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->show();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 QCOMPARE(m_axis->isVisible(), true);
             }
             void tst_QAbstractAxis::hide_data()
             {
             }
             void tst_QAbstractAxis::hide()
             {
                 m_axis->show();
                 QCOMPARE(m_axis->isVisible(),true);
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
                 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
                 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
                 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
                 m_axis->hide();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), 0);
                 QCOMPARE(spy6.count(), 0);
                 QCOMPARE(spy7.count(), 0);
                 QCOMPARE(spy8.count(), 1);
                 QCOMPARE(m_axis->isVisible(),false);
             }

tests/chartdesigner/engine.cpp 0 -1

             /****************************************************************************
              **
              ** Copyright (C) 2013 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 "engine.h"
             #include <QItemSelectionModel>
             #include <QStandardItemModel>
             #include <QVXYModelMapper>
             #include <QHBarModelMapper>
             #include <QVPieModelMapper>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QAreaSeries>
             #include <QPieSeries>
             #include <QChart>
             #include <QBarSet>
             const qint32 MAGIC_NUMBER = 0x66666666;
             Engine::Engine(QObject* parent) :
                 QObject(parent), m_count(10), m_chart(new QChart()), m_model(0), m_selection(0)
             {
                 createModels();
             }
             Engine::~Engine()
             {
                 delete m_chart;
                 delete m_selection;
                 delete m_model;
             }
             void Engine::createModels()
             {
                 m_model = new QStandardItemModel(m_count, m_count);
                 m_model->setHorizontalHeaderLabels(
                     QStringList() << "A" << "B" << "C" << "D" << "E" << "F" << "G" << "H" << "I" << "J");
                 m_model->setVerticalHeaderLabels(
                     QStringList() << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9" << "10");
                 m_selection = new QItemSelectionModel(m_model);
             }
             QList<QAbstractSeries*> Engine::addSeries(QAbstractSeries::SeriesType type)
             {
                 const QModelIndexList& list = m_selection->selectedIndexes();
                 QMap<int, QModelIndex> columns;
                 foreach (const QModelIndex& index, list) {
                     columns.insertMulti(index.column(), index);
                 }
                 QList<int> keys = columns.uniqueKeys();
                 QModelIndexList rows = columns.values(keys.first());
                 int minRow = m_count + 1;
                 int maxRow = -1;
                 foreach (const QModelIndex& index, rows) {
                     minRow = qMin(index.row(), minRow);
                     maxRow = qMax(index.row(), maxRow);
                 }
                 QList<QAbstractSeries*> result;
                 QColor color;
                 switch (type) {
                 case QAbstractSeries::SeriesTypeLine:
                 {
                     for (int i = 1; i < keys.count(); ++i) {
                         QLineSeries *line = new QLineSeries();
                         setupXYSeries(line, keys, i, minRow, maxRow);
                         result << line;
                     }
                     break;
                 }
                 case QAbstractSeries::SeriesTypeSpline:
                 {
                     for (int i = 1; i < keys.count(); ++i) {
                         QSplineSeries *line = new QSplineSeries();
                         setupXYSeries(line, keys, i, minRow, maxRow);
                         result << line;
                     }
                     break;
                 }
                 case QAbstractSeries::SeriesTypeScatter:
                 {
                     for (int i = 1; i < keys.count(); ++i) {
                         QScatterSeries *line = new QScatterSeries();
                         setupXYSeries(line, keys, i, minRow, maxRow);
                         result << line;
                     }
                     break;
                 }
                 case QAbstractSeries::SeriesTypeBar:
                 {
-                    //TODO: fix me
                     QBarSeries *bar = new QBarSeries();
                     setupBarSeries(bar,keys,minRow,maxRow);
                     result << bar;
                     break;
                 }
                 case QAbstractSeries::SeriesTypePercentBar:
                 {
                     QPercentBarSeries *bar = new QPercentBarSeries();
                     setupBarSeries(bar,keys,minRow,maxRow);
                     result << bar;
                     break;
                 }
                 case QAbstractSeries::SeriesTypeStackedBar:
                 {
                     QStackedBarSeries *bar = new QStackedBarSeries();
                     setupBarSeries(bar,keys,minRow,maxRow);
                     result << bar;
                     break;
                 }
                 case QAbstractSeries::SeriesTypePie:
                 {
                     QPieSeries *pie = new QPieSeries();
                     setupPieSeries(pie,keys,minRow,maxRow);
                     result << pie;
                     break;
                 }
                 case QAbstractSeries::SeriesTypeArea:
                 {
                      QAreaSeries *area = new QAreaSeries( new QLineSeries(), new QLineSeries());
                      setupAreaSeries(area,keys,minRow,maxRow);
                      result << area;
                      break;
                 }
                 }
                 m_chart->createDefaultAxes();
                 return result;
             }
             void Engine::removeSeries(QAbstractSeries* series)
             {
                 m_chart->removeSeries(series);
                 foreach (const QModelIndex& index, m_seriesModelIndex.value(series)) {
                     m_model->setData(index, Qt::white, Qt::BackgroundRole);
                 }
             }
             void Engine::clearModels()
             {
                 delete m_selection;
                 m_selection = 0;
                 delete m_model;
                 m_model = 0;
                 createModels();
             }
             bool Engine::save(const QString &filename) const
             {
                 if (filename.isEmpty())
                     return false;
                 QFile file(filename);
                 if (!file.open(QIODevice::WriteOnly)) {
                     return false;
                 }
                 QDataStream out(&file);
                 out << MAGIC_NUMBER;
                 out.setVersion(QDataStream::Qt_4_8);
                 out << m_model->rowCount();
                 out << m_model->columnCount();
                 for (int row = 0; row < m_model->rowCount(); ++row) {
                     for (int column = 0; column < m_model->columnCount(); ++column) {
                         QStandardItem *item = m_model->item(row, column);
                         if (item) {
                                 out << row;
                                 out << column;
                                 out << item->data(Qt::EditRole).toString();
                         }
                     }
                 }
                 return true;
             }
             bool Engine::load(const QString &filename)
             {
                 clearModels();
                 if (filename.isEmpty())
                     return false;
                 QFile file(filename);
                 if (!file.open(QIODevice::ReadOnly)) {
                     return false;
                 }
                 QDataStream in(&file);
                 qint32 magicNumber;
                 in >> magicNumber;
                 if (magicNumber != MAGIC_NUMBER)
                     return false;
                 in.setVersion(QDataStream::Qt_4_8);
                 int rowCount;
                 in >> rowCount;
                 int columnCount;
                 in >> columnCount;
                 while (!in.atEnd()) {
                     int row;
                     int column;
                     QString value;
                     in >> row >> column >> value;
                     QStandardItem *item = new QStandardItem();
                     bool ok;
                     double result = value.toDouble(&ok);
                     if(ok)
                         item->setData(result, Qt::EditRole);
                     else
                         item->setData(value, Qt::EditRole);
                     m_model->setItem(row, column, item);
                 }
                 return true;
             }
             void Engine::setupXYSeries(QXYSeries *xyseries, const QList<int>& columns, int column, int minRow, int maxRow)
             {
                 QVXYModelMapper* mapper = new QVXYModelMapper(xyseries);
                 mapper->setSeries(xyseries);
                 mapper->setModel(m_model);
                 mapper->setXColumn(columns.first());
                 mapper->setYColumn(columns.at(column));
                 mapper->setFirstRow(minRow);
                 mapper->setRowCount(maxRow - minRow + 1);
                 m_chart->addSeries(xyseries);
                 xyseries->setName(QString("Series %1").arg(m_chart->series().count()));
                 QObject::connect(xyseries,SIGNAL(clicked(QPointF)),this,SIGNAL(selected()));
                 const QModelIndexList& list = m_selection->selectedIndexes();
                 QModelIndexList result;
                 foreach (const QModelIndex& index, list) {
                     if (index.column() ==columns.at(column)){
                         m_model->setData(index, xyseries->pen().color(), Qt::BackgroundRole);
                         result << index;
                     }
                 }
                 m_seriesModelIndex.insert(xyseries,result);
             }
             void Engine::setupBarSeries(QAbstractBarSeries *bar, const QList<int>& columns, int minRow, int maxRow)
             {
                 QHBarModelMapper* mapper = new QHBarModelMapper(bar);
                 mapper->setSeries(bar);
                 mapper->setModel(m_model);
                 mapper->setFirstColumn(minRow);
                 mapper->setColumnCount(maxRow - minRow + 1);
                 mapper->setFirstBarSetRow(columns.at(1));
                 mapper->setLastBarSetRow(columns.last());
                 m_chart->addSeries(bar);
                 bar->setName(QString("Series %1").arg(m_chart->series().count()));
                 const QModelIndexList& list = m_selection->selectedIndexes();
                 foreach (const QModelIndex& index, list) {
                     if (index.column() >= columns.at(1) && index.column()<= columns.last()) {
                         //m_model->setData(index, bar->barSets().at(index.column())->brush().color(), Qt::BackgroundRole);
                     }
                 }
             }
             void Engine::setupPieSeries(QPieSeries *pie, const QList<int>& columns, int minRow, int maxRow)
             {
                 QVPieModelMapper* mapper = new QVPieModelMapper(pie);
                 mapper->setSeries(pie);
                 mapper->setModel(m_model);
                 mapper->setValuesColumn(columns.at(1));
                 mapper->setLabelsColumn(columns.first());
                 mapper->setFirstRow(minRow);
                 mapper->setRowCount(maxRow - minRow + 1);
                 m_chart->addSeries(pie);
                 pie->setName(QString("Series %1").arg(m_chart->series().count()));
                 const QModelIndexList& list = m_selection->selectedIndexes();
                 foreach (const QModelIndex& index, list) {
                    // m_model->setData(index, bar->barSets()pen().color(), Qt::BackgroundRole);
                 }
             }
             void Engine::setupAreaSeries(QAreaSeries *series, const QList<int>& columns, int minRow, int maxRow)
             {
                 QVXYModelMapper* umapper = new QVXYModelMapper(series);
                 umapper->setSeries(series->upperSeries());
                 umapper->setModel(m_model);
                 umapper->setXColumn(columns.first());
                 umapper->setYColumn(columns.at(1));
                 umapper->setFirstRow(minRow);
                 umapper->setRowCount(maxRow - minRow + 1);
                 QVXYModelMapper* lmapper = new QVXYModelMapper(series);
                 lmapper->setSeries(series->lowerSeries());
                 lmapper->setModel(m_model);
                 lmapper->setXColumn(columns.first());
                 lmapper->setYColumn(columns.at(2));
                 lmapper->setFirstRow(minRow);
                 lmapper->setRowCount(maxRow - minRow + 1);
                 m_chart->addSeries(series);
                 series->setName(QString("Series %1").arg(m_chart->series().count()));
                 const QModelIndexList& list = m_selection->selectedIndexes();
                 foreach (const QModelIndex& index, list) {
                     //if (index.column() ==columns.at(column))
                       //  m_model->setData(index, xyseries->pen().color(), Qt::BackgroundRole);
                 }
             }

tests/chartwidgettest/mainwidget.cpp 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartview.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qlineseries.h"
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             #include <QBarCategoryAxis>
             #include <QGLWidget>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
                 QCheckBox *openGLCheckBox = new QCheckBox("Use QGLWidget");
                 connect(openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(openGLToggled(bool)));
                 openGLCheckBox->setChecked(false);
                 grid->addWidget(openGLCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::openGLToggled(bool enabled)
             {
                 if (enabled) {
                     QGLFormat f = QGLFormat::defaultFormat();
                     f.setSampleBuffers(true);
                     f.setSamples(4);
                     QGLFormat::setDefaultFormat(f);
                     QGLWidget *g = new QGLWidget();
                     m_chartView->setViewport(g);
                 } else {
                     m_chartView->setViewport(0);
                 }
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
                             this, SLOT(addSeries(QString,int,int,QString,bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
-                // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(labels.at(i), column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach (QString label, labels)
                         category << label;
                     QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else {
                         series = new QPercentBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     }
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
                         series->append(set);
                     }
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
                 m_chart->createDefaultAxes();
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chart->setTheme((QChart::ChartTheme) themeIndex);
             }

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