HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2575:f9a133cb3e77

Remove TODOs...

Miikka Heikkinen -

r2575:f9a133cb3e77

parent child

Context file:

r2575:f9a133cb3e77

Collapse all files

plugins/declarative/plugin.cpp 0 -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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "qlogvalueaxis.h"
             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
             #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativepieseries.h"
             #include "declarativeaxes.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include "declarativemargins.h"
             #include "qarealegendmarker.h"
             #include "qbarlegendmarker.h"
             #include "qpielegendmarker.h"
             #include "qxylegendmarker.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #include "shared_defines.h"
             #include <QAbstractItemModel>
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlExtensionPlugin>
             #else
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #endif
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QList<QPieSlice *>)
             Q_DECLARE_METATYPE(QList<QBarSet *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
-            // NOTE: Hackish fixes for Qt5 (beta2).
-            // These should not be needed or at least they are not needed in Qt4.
             Q_DECLARE_METATYPE(DeclarativeChart *)
             Q_DECLARE_METATYPE(DeclarativePolarChart *)
             Q_DECLARE_METATYPE(DeclarativeMargins *)
             Q_DECLARE_METATYPE(DeclarativeAreaSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSet *)
             Q_DECLARE_METATYPE(DeclarativeBoxPlotSeries *)
             Q_DECLARE_METATYPE(DeclarativeBoxSet *)
             Q_DECLARE_METATYPE(DeclarativeLineSeries *)
             Q_DECLARE_METATYPE(DeclarativePieSeries *)
             Q_DECLARE_METATYPE(DeclarativeScatterSeries *)
             Q_DECLARE_METATYPE(DeclarativeSplineSeries *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QCategoryAxis *)
             Q_DECLARE_METATYPE(QDateTimeAxis *)
             Q_DECLARE_METATYPE(QLogValueAxis *)
             Q_DECLARE_METATYPE(QLegend *)
             Q_DECLARE_METATYPE(QLegendMarker *)
             Q_DECLARE_METATYPE(QAreaLegendMarker *)
             Q_DECLARE_METATYPE(QBarLegendMarker *)
             Q_DECLARE_METATYPE(QPieLegendMarker *)
             Q_DECLARE_METATYPE(QHPieModelMapper *)
             Q_DECLARE_METATYPE(QHXYModelMapper *)
             Q_DECLARE_METATYPE(QPieModelMapper *)
             Q_DECLARE_METATYPE(QHBarModelMapper *)
             Q_DECLARE_METATYPE(QBarModelMapper *)
             Q_DECLARE_METATYPE(QVBarModelMapper *)
             Q_DECLARE_METATYPE(QVPieModelMapper *)
             Q_DECLARE_METATYPE(QVXYModelMapper *)
             Q_DECLARE_METATYPE(QXYLegendMarker *)
             Q_DECLARE_METATYPE(QXYModelMapper *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QXYSeries *)
             Q_DECLARE_METATYPE(QAbstractBarSeries *)
             Q_DECLARE_METATYPE(QBarSeries *)
             Q_DECLARE_METATYPE(QBarSet *)
             Q_DECLARE_METATYPE(QAreaSeries *)
             Q_DECLARE_METATYPE(QHorizontalBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalPercentBarSeries *)
             Q_DECLARE_METATYPE(QHorizontalStackedBarSeries *)
             Q_DECLARE_METATYPE(QLineSeries *)
             Q_DECLARE_METATYPE(QPercentBarSeries *)
             Q_DECLARE_METATYPE(QPieSeries *)
             Q_DECLARE_METATYPE(QPieSlice *)
             Q_DECLARE_METATYPE(QScatterSeries *)
             Q_DECLARE_METATYPE(QSplineSeries *)
             Q_DECLARE_METATYPE(QStackedBarSeries *)
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDECLARATIVE_EXTENSION_PLUGIN
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
             #else
             # if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDeclarativeExtensionInterface")
             # endif
             #endif
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     qRegisterMetaType<QList<QAbstractAxis *> >();
                     // QtCommercial.Chart 1.0
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                         QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                           QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                                    QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                                 QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                                    QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                               QLatin1String("Trying to create uncreatable: AbstractAxis. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     qmlRegisterUncreatableType<DeclarativeAxes>(uri, 1, 0, "DeclarativeAxes",
                                                            QLatin1String("Trying to create uncreatable: DeclarativeAxes."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
                     qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCommercial.Chart 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 2>(uri, 1, 2, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 2>(uri, 1, 2, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 2>(uri, 1, 2, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 2>(uri, 1, 2, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 2>(uri, 1, 2, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 2>(uri, 1, 2, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 2>(uri, 1, 2, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
                     // QtCommercial.Chart 1.3
                     qmlRegisterType<DeclarativeChart, 3>(uri, 1, 3, "ChartView");
                     qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
                     qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
                     qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                     qmlRegisterType<QLogValueAxis>(uri, 1, 3, "LogValueAxis");
                     qmlRegisterType<DeclarativeBoxPlotSeries>(uri, 1, 3, "BoxPlotSeries");
                     qmlRegisterType<DeclarativeBoxSet>(uri, 1, 3, "BoxSet");
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

src/animations/axisanimation.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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "axisanimation_p.h"
             #include "chartaxiselement_p.h"
             #include "qabstractaxis_p.h"
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisAnimation::AxisAnimation(ChartAxisElement *axis)
                 : ChartAnimation(axis),
                   m_axis(axis),
                   m_type(DefaultAnimation)
             {
                 setDuration(ChartAnimationDuration);
                 setEasingCurve(QEasingCurve::OutQuart);
             }
             AxisAnimation::~AxisAnimation()
             {
             }
             void AxisAnimation::setAnimationType(Animation type)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_type = type;
             }
             void AxisAnimation::setAnimationPoint(const QPointF &point)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_point = point;
             }
             void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
             {
                 if (state() != QAbstractAnimation::Stopped) stop();
-            //  TODO: cannot return even if layout is empty
-            //  New layout is not set properly without it (crash)
-            //    if (newLayout.count() == 0)
-            //        return;
                 switch (m_type) {
                 case ZoomOutAnimation: {
                     QRectF rect = m_axis->gridGeometry();
                     oldLayout.resize(newLayout.count());
                     for (int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
                         oldLayout[i] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.left() : rect.bottom();
                         oldLayout[j] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.right() : rect.top();
                     }
                 }
                 break;
                 case ZoomInAnimation: {
                     int index = qMin(oldLayout.count() * (m_axis->axis()->orientation() == Qt::Horizontal ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
                     oldLayout.resize(newLayout.count());
                     for (int i = 0; i < oldLayout.count(); i++)
                         oldLayout[i] = oldLayout[index];
                 }
                 break;
                 case MoveForwardAnimation: {
                     oldLayout.resize(newLayout.count());
                     for (int i = 0, j = i + 1; i < oldLayout.count() - 1; ++i, ++j)
                         oldLayout[i] = oldLayout[j];
                 }
                 break;
                 case MoveBackwordAnimation: {
                     oldLayout.resize(newLayout.count());
                     for (int i = oldLayout.count() - 1, j = i - 1; i > 0; --i, --j)
                         oldLayout[i] = oldLayout[j];
                 }
                 break;
                 default: {
                     oldLayout.resize(newLayout.count());
                     QRectF rect = m_axis->gridGeometry();
                     for (int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
                         oldLayout[i] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.left() : rect.top();
                 }
                 break;
                 }
                 QVariantAnimation::KeyValues value;
                 setKeyValues(value); //workaround for wrong interpolation call
                 setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 setKeyValueAt(1.0, qVariantFromValue(newLayout));
             }
             QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
                 QVector<qreal> startVector = qvariant_cast<QVector<qreal> >(start);
                 QVector<qreal> endVecotr = qvariant_cast<QVector<qreal> >(end);
                 QVector<qreal> result;
                 Q_ASSERT(startVector.count() == endVecotr.count()) ;
                 for (int i = 0; i < startVector.count(); i++) {
                     qreal value = startVector[i] + ((endVecotr[i] - startVector[i]) * progress); //qBound(0.0, progress, 1.0));
                     result << value;
                 }
                 return qVariantFromValue(result);
             }
             void AxisAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
                     QVector<qreal> vector = qvariant_cast<QVector<qreal> >(value);
             //        Q_ASSERT(vector.count() != 0);
                     m_axis->setLayout(vector);
                     m_axis->updateGeometry();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem.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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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),
                   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) {
                     // Note: Polarcharts always draw area correctly only when both series have equal width or are
                     // fully displayed. If one series is partally off-chart, the connecting line between
                     // the series does not attach to the end of the partially hidden series but to the point
                     // where it intersects the axis line. The problem is especially noticeable when one of the series
                     // is entirely off-chart, in which case the connecting line connects two ends of the
                     // visible series.
                     // This happens because we get the paths from linechart, which omits off-chart segments.
                     // To properly fix, linechart would need to provide true full path, in right, left, and the rest
                     // portions to enable proper clipping. However, combining those to single visually unified area
                     // would be a nightmare, since they would have to be painted separately.
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     if (presenter()->chartType() == QChart::ChartTypeCartesian) {
                         path.lineTo(last.x(), rect.bottom());
                         path.lineTo(first.x(), rect.bottom());
                     } else { // polar
                         path.lineTo(rect.center());
                     }
                 }
                 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);
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 if (presenter()->chartType() == QChart::ChartTypePolar)
                     painter->setClipRegion(QRegion(clipRect.toRect(), QRegion::Ellipse));
                 else
                     painter->setClipRect(clipRect);
                 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/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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item)
                 : HorizontalAxis(axis, item, true),
                   m_axis(axis)
             {
                 QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
             }
             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();
             }
             QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 qreal width = 0; // Width is irrelevant for X axes with interval labels
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     height = boundingRect.height() + labelPadding() + base.height() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelHeight = 0.0;
                     foreach (const QString& s, ticksList) {
                         QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                     }
                     height = labelHeight + labelPadding() + base.height() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             void ChartCategoryAxisX::handleCategoriesChanged()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             #include "moc_chartcategoryaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisangular.cpp 0 -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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "polarchartaxisangular_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include <QDebug>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PolarChartAxisAngular::PolarChartAxisAngular(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisAngular::~PolarChartAxisAngular()
             {
             }
             void PolarChartAxisAngular::updateGeometry()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 const QVector<qreal> &layout = this->layout();
                 if (layout.isEmpty())
                     return;
                 createAxisLabels(layout);
                 QStringList labelList = labels();
                 QPointF center = axisGeometry().center();
                 QList<QGraphicsItem *> arrowItemList = arrowItems();
                 QList<QGraphicsItem *> gridItemList = gridItems();
                 QList<QGraphicsItem *> labelItemList = labelItems();
                 QList<QGraphicsItem *> shadeItemList = shadeItems();
                 QGraphicsTextItem *title = titleItem();
                 QGraphicsEllipseItem *axisLine = static_cast<QGraphicsEllipseItem *>(arrowItemList.at(0));
                 axisLine->setRect(axisGeometry());
                 qreal radius = axisGeometry().height() / 2.0;
                 QRectF previousLabelRect;
                 QRectF firstLabelRect;
                 qreal labelHeight = 0;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > 360.0);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal angularCoordinate = layout.at(i);
                     QGraphicsLineItem *gridLineItem = static_cast<QGraphicsLineItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labelItemList.at(i));
                     QGraphicsPathItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
                     // Ignore ticks outside valid range
                     bool currentTickVisible = nextTickVisible;
                     if ((i == layout.size() - 1)
                         || layout.at(i + 1) < 0.0
                         || layout.at(i + 1) > 360.0) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = angularCoordinate;
                     qreal labelVisible = currentTickVisible;
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = 360.0;
                         else
                             farEdge = qMin(qreal(360.0), layout.at(i + 1));
                         // Adjust the labelCoordinate to show it if next tick is visible
                         if (nextTickVisible)
                             labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                         labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         // Don't display label once the category gets too small near the axis
                         if (labelCoordinate < 5.0 || labelCoordinate > 355.0)
                             labelVisible = false;
                         else
                             labelVisible = true;
                     }
                     // Need this also in label calculations, so determine it first
                     QLineF tickLine(QLineF::fromPolar(radius - tickWidth(), 90.0 - angularCoordinate).p2(),
                                     QLineF::fromPolar(radius + tickWidth(), 90.0 - angularCoordinate).p2());
                     tickLine.translate(center);
                     // Angular axis label
                     if (axis()->labelsVisible() && labelVisible) {
                         labelItem->setHtml(labelList.at(i));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(rect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint;
                         if (intervalAxis()) {
                             QLineF labelLine = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate);
                             labelLine.translate(center);
                             labelPoint = labelLine.p2();
                         } else {
                             labelPoint = tickLine.p2();
                         }
                         QRectF labelRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Store height for title calculations
                         qreal labelClearance = axisGeometry().top() - labelRect.top();
                         labelHeight = qMax(labelHeight, labelClearance);
                         // Label overlap detection
                         if (i && (previousLabelRect.intersects(labelRect) || firstLabelRect.intersects(labelRect))) {
                             labelVisible = false;
                         } else {
                             // Store labelRect for future comparison. Some area is deducted to make things look
                             // little nicer, as usually intersection happens at label corner with angular labels.
                             labelRect.adjust(-2.0, -4.0, -2.0, -4.0);
                             if (firstLabelRect.isEmpty())
                                 firstLabelRect = labelRect;
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridLineItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Angular grid line
                     QLineF gridLine = QLineF::fromPolar(radius, 90.0 - angularCoordinate);
                     gridLine.translate(center);
                     gridLineItem->setLine(gridLine);
                     gridLineItem->setVisible(true);
                     // Tick
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         path.moveTo(center);
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the first partial arc
                             // or it won't get filled.
                             path.arcTo(axisGeometry(), 90.0 - layout.at(0), layout.at(0));
                             path.closeSubpath();
                         } else {
                             qreal nextCoordinate;
                             if (!nextTickVisible) // Last visible tick
                                 nextCoordinate = 360.0;
                             else
                                 nextCoordinate = layout.at(i + 1);
                             qreal arcSpan = angularCoordinate - nextCoordinate;
                             path.arcTo(axisGeometry(), 90.0 - angularCoordinate, arcSpan);
                             path.closeSubpath();
                             // Add additional arc for first shade item if there is a partial arc to be filled
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QPainterPath specialPath;
                                     specialPath.moveTo(center);
                                     specialPath.arcTo(axisGeometry(), 90.0 - layout.at(i - 1), layout.at(i - 1));
                                     specialPath.closeSubpath();
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                 }
                 // Title, centered above the chart
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
                     QRectF dummyRect;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), axisGeometry().width(), Qt::Horizontal, dummyRect));
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = center - titleBoundingRect.center();
                     title->setPos(titleCenter.x(), axisGeometry().top() - titlePadding() * 2.0 - titleBoundingRect.height() - labelHeight);
                 }
             }
             Qt::Orientation PolarChartAxisAngular::orientation() const
             {
                 return Qt::Horizontal;
             }
             void PolarChartAxisAngular::createItems(int count)
             {
                 if (arrowItems().count() == 0) {
                     // angular axis line
-                    // TODO: need class similar to LineArrowItem for click handling?
                     QGraphicsEllipseItem *arrow = new QGraphicsEllipseItem(presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsLineItem *grid = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
                     QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
                     title->setDefaultTextColor(axis()->titleBrush().color());
                     title->setHtml(axis()->titleText());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
                         shade->setPen(axis()->shadesPen());
                         shade->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shade);
                     }
                 }
             }
             void PolarChartAxisAngular::handleArrowPenChanged(const QPen &pen)
             {
                 bool first = true;
                 foreach (QGraphicsItem *item, arrowItems()) {
                     if (first) {
                         first = false;
                         // First arrow item is the outer circle of axis
                         static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
                     } else {
                         static_cast<QGraphicsLineItem *>(item)->setPen(pen);
                     }
                 }
             }
             void PolarChartAxisAngular::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             QSizeF PolarChartAxisAngular::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1, -1);
             }
             qreal PolarChartAxisAngular::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 if (axis()->labelsVisible()) {
                     QVector<qreal> layout = calculateLayout();
                     if (layout.isEmpty())
                         return radius;
                     createAxisLabels(layout);
                     QStringList labelList = labels();
                     QFont font = axis()->labelsFont();
                     QRectF maxRect;
                     maxRect.setSize(maxSize);
                     maxRect.moveCenter(QPointF(0.0, 0.0));
                     // This is a horrible way to find out the maximum radius for angular axis and its labels.
                     // It just increments the radius down until everyhing fits the constraint size.
                     // Proper way would be to actually calculate it but this seems to work reasonably fast as it is.
                     bool nextTickVisible = false;
                     for (int i = 0; i < layout.size(); ) {
                         if ((i == layout.size() - 1)
                             || layout.at(i + 1) < 0.0
                             || layout.at(i + 1) > 360.0) {
                             nextTickVisible = false;
                         } else {
                             nextTickVisible = true;
                         }
                         qreal labelCoordinate = layout.at(i);
                         qreal labelVisible;
                         if (intervalAxis()) {
                             qreal farEdge;
                             if (i == (layout.size() - 1))
                                 farEdge = 360.0;
                             else
                                 farEdge = qMin(qreal(360.0), layout.at(i + 1));
                             // Adjust the labelCoordinate to show it if next tick is visible
                             if (nextTickVisible)
                                 labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                             labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         }
                         if (labelCoordinate < 0.0 || labelCoordinate > 360.0)
                             labelVisible = false;
                         else
                             labelVisible = true;
                         if (!labelVisible) {
                             i++;
                             continue;
                         }
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         QPointF labelPoint = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate).p2();
                         boundingRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         QRectF intersectRect = maxRect.intersected(boundingRect);
                         if (boundingRect.isEmpty() || intersectRect == boundingRect) {
                             i++;
                         } else {
                             qreal reduction(0.0);
                             // If there is no intersection, reduce by smallest dimension of label rect to be on the safe side
                             if (intersectRect.isEmpty()) {
                                 reduction = qMin(boundingRect.height(), boundingRect.width());
                             } else {
                                 // Approximate needed radius reduction is the amount label rect exceeds max rect in either dimension.
                                 // Could be further optimized by figuring out the proper math how to calculate exact needed reduction.
                                 reduction = qMax(boundingRect.height() - intersectRect.height(),
                                                  boundingRect.width() - intersectRect.width());
                             }
                             // Typically the approximated reduction is little low, so add one
                             radius -= (reduction + 1.0);
                             if (radius < 1.0) // safeguard
                                 return 1.0;
                         }
                     }
                 }
                 if (!axis()->titleText().isEmpty() && axis()->isTitleVisible()) {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     radius -= titlePadding() + (titleRect.height() / 2.0);
                     if (radius < 1.0) // safeguard
                         return 1.0;
                 }
                 return radius;
             }
             QRectF PolarChartAxisAngular::moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const
             {
-                // TODO use fuzzy compare for "==" cases?
-                // TODO Adjust the rect position near 0, 90, 180, and 270 angles for smoother animation?
                 if (angularCoordinate == 0.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 else if (angularCoordinate < 90.0)
                     labelRect.moveBottomLeft(labelPoint);
                 else if (angularCoordinate == 90.0)
                     labelRect.moveCenter(labelPoint + QPointF(labelRect.width() / 2.0 + 2.0, 0)); // +2 so that it does not hit the radial axis
                 else if (angularCoordinate < 180.0)
                     labelRect.moveTopLeft(labelPoint);
                 else if (angularCoordinate == 180.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, labelRect.height() / 2.0));
                 else if (angularCoordinate < 270.0)
                     labelRect.moveTopRight(labelPoint);
                 else if (angularCoordinate == 270.0)
                     labelRect.moveCenter(labelPoint + QPointF(-labelRect.width() / 2.0 - 2.0, 0)); // -2 so that it does not hit the radial axis
                 else if (angularCoordinate < 360.0)
                     labelRect.moveBottomRight(labelPoint);
                 else
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 return labelRect;
             }
             #include "moc_polarchartaxisangular_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                 that would result in different domains is not supported, such as specifying
                 QValueAxis and QLogValueAxis on the same orientation.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \qmlclass AbstractAxis QAbstractAxis
                 \brief The AbstractAxis is a base element used for specialized axis elements.
                 Each series can be bound to only one horizontal and vertical axis.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \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
               \deprecated
               The pen of the labels.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels. Only the color of the brush is relevant.
             */
             /*!
               \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. Axis titles support html formatting.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \property QAbstractAxis::titlePen
               \deprecated
               The pen of the title text.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text. Only the color of the brush is relevant.
             */
             /*!
               \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 series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
               \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)
               \deprecated
               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)
               \deprecated
               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
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_axisPen;
             }
-            //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 linePen().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
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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;
             }
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
             QPen QAbstractAxis::labelsPen() const
             {
                 if (d_ptr->m_labelsPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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 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 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;
             }
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             QPen QAbstractAxis::titlePen() const
             {
                 if (d_ptr->m_titlePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     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 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 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_axisPen(QChartPrivate::defaultPen()),
                   m_axisBrush(QChartPrivate::defaultBrush()),
                   m_gridLineVisible(true),
                   m_gridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsPen(QChartPrivate::defaultPen()),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titlePen(QChartPrivate::defaultPen()),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   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)
             {
-                //TODO: introduce axis brush
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->girdLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_labelsPen)
                     q_ptr->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
                     q_ptr->setLabelsFont(theme->labelFont());
                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
                     q_ptr->setTitleBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_titlePen)
                     q_ptr->setTitlePen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
                     QFont font(m_labelsFont);
                     font.setBold(true);
                     q_ptr->setTitleFont(font);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                      q_ptr->setShadesVisible(true);
                 } else if (forced) {
                     q_ptr->setShadesVisible(false);
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (axis->animation())
                     axis->animation()->stopAndDestroyLater();
                 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 -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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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)
                 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 (2.0)
+                Qt::Orientation orientation();
                 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 ChartPresenter;
                 friend class ChartThemeManager;
                 friend class AbstractDomain;
                 friend class ChartAxisElement;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

src/axis/valueaxis/qvalueaxis.h 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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: 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 Qt Enterprise 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 deprecated (2.0)
+                bool m_niceNumbersEnabled;
                 Q_DECLARE_PUBLIC(QValueAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUEAXIS_P_H

src/chartpresenter_p.h 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 Qt Enterprise 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" //because of QChart::ChartThemeId
             #include <QRectF>
             #include <QMargins>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void 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; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle, qreal maxSize,
                                              Qt::Orientation constraintOrientation, QRectF &boundingRect);
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/chartthememanager.cpp 0 -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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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_p.h"
             #include "qabstractaxis_p.h"
             #include <QTime>
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartThemeManager::ChartThemeManager(QChart* chart) :
                 m_chart(chart)
             {
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
             }
             void ChartThemeManager::setTheme(QChart::ChartTheme theme)
             {
                 if (m_theme.isNull() || theme != m_theme->id()) {
                     switch (theme) {
                     case QChart::ChartThemeLight:
                         m_theme.reset(new ChartThemeLight());
                         break;
                     case QChart::ChartThemeBlueCerulean:
                         m_theme.reset(new ChartThemeBlueCerulean());
                         break;
                     case QChart::ChartThemeDark:
                         m_theme.reset(new ChartThemeDark());
                         break;
                     case QChart::ChartThemeBrownSand:
                         m_theme.reset(new ChartThemeBrownSand());
                         break;
                     case QChart::ChartThemeBlueNcs:
                         m_theme.reset(new ChartThemeBlueNcs());
                         break;
                     case QChart::ChartThemeHighContrast:
                         m_theme.reset(new ChartThemeHighContrast());
                         break;
                     case QChart::ChartThemeBlueIcy:
                         m_theme.reset(new ChartThemeBlueIcy());
                         break;
                     default:
                         m_theme.reset(new ChartThemeSystem());
                         break;
                     }
                     if (!m_theme.isNull()) {
                         decorateChart(m_chart,m_theme.data());
                         decorateLegend(m_chart->legend(),m_theme.data());
                         foreach (QAbstractAxis* axis, m_axisList)
                             axis->d_ptr->initializeTheme(m_theme.data(), true);
                         foreach (QAbstractSeries* series, m_seriesMap.keys())
                             series->d_ptr->initializeTheme(m_seriesMap[series], m_theme.data(), true);
                     }
                 }
             }
             // decorateChart is only called when theme is forcibly initialized
             void ChartThemeManager::decorateChart(QChart *chart, ChartTheme *theme) const
             {
                 chart->setBackgroundBrush(theme->chartBackgroundGradient());
                 QPen pen(Qt::transparent);
                 QBrush brush;
                 chart->setPlotAreaBackgroundBrush(brush);
                 chart->setPlotAreaBackgroundPen(pen);
                 chart->setPlotAreaBackgroundVisible(false);
                 chart->setTitleFont(theme->masterFont());
                 chart->setTitleBrush(theme->labelBrush());
                 chart->setDropShadowEnabled(theme->isBackgroundDropShadowEnabled());
             }
             // decorateLegend is only called when theme is forcibly initialized
             void ChartThemeManager::decorateLegend(QLegend *legend, ChartTheme *theme) const
             {
                 legend->setPen(theme->axisLinePen());
                 legend->setBrush(theme->chartBackgroundGradient());
                 legend->setFont(theme->labelFont());
                 legend->setLabelBrush(theme->labelBrush());
             }
             int ChartThemeManager::createIndexKey(QList<int> keys) const
             {
                 qSort(keys);
                 int key = 0;
                 QList<int>::iterator i;
                 i = keys.begin();
                 while (i != keys.end()) {
                     if (*i != key)
                         break;
                     key++;
                     i++;
                 }
                 return key;
             }
             int ChartThemeManager::seriesCount(QAbstractSeries::SeriesType type) const
             {
                 int count = 0;
                 QList<QAbstractSeries *> series =   m_seriesMap.keys();
                 foreach(QAbstractSeries *s, series) {
                     if (s->type() == type)
                         count++;
                 }
                 return count;
             }
             void ChartThemeManager::handleSeriesAdded(QAbstractSeries *series)
             {
                 int key = createIndexKey(m_seriesMap.values());
                 m_seriesMap.insert(series,key);
                 series->d_ptr->initializeTheme(key,m_theme.data(),false);
             }
             void ChartThemeManager::handleSeriesRemoved(QAbstractSeries *series)
             {
                 m_seriesMap.remove(series);
             }
             void ChartThemeManager::handleAxisAdded(QAbstractAxis *axis)
             {
                 m_axisList.append(axis);
                 axis->d_ptr->initializeTheme(m_theme.data(),false);
             }
             void ChartThemeManager::handleAxisRemoved(QAbstractAxis *axis)
             {
                 m_axisList.removeAll(axis);
             }
             void ChartThemeManager::updateSeries(QAbstractSeries *series)
             {
                 if(m_seriesMap.contains(series)){
                     series->d_ptr->initializeTheme(m_seriesMap[series],m_theme.data(),false);
                 }
             }
             QList<QGradient> ChartThemeManager::generateSeriesGradients(const QList<QColor>& colors)
             {
                 QList<QGradient> result;
                 // Generate gradients in HSV color space
                 foreach (const QColor &color, colors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
-                    // TODO: tune the algorithm to give nice results with most base colors defined in
-                    // most themes. The rest of the gradients we can define manually in theme specific
-                    // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     result << g;
                 }
                 return result;
             }
             QColor ChartThemeManager::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartThemeManager::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             #include "moc_chartthememanager_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegendmarker_p.h 0 -7

             /****************************************************************************
             **
             ** 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 Qt Enterprise 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 QLEGENDMARKERPRIVATE_H
             #define QLEGENDMARKERPRIVATE_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsLayoutItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            // TODO: check these
             class QAbstractSeries;
-            class QAreaSeries;
-            class QXYSeries;
-            class QBarSet;
-            class QAbstractBarSeries;
-            class QPieSlice;
             class QLegend;
-            class QPieSeries;
             class QLegendMarker;
             class LegendMarkerItem;
             class QLegendMarkerPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QLegendMarkerPrivate(QLegendMarker *q, QLegend *legend);
                 virtual ~QLegendMarkerPrivate();
                 // Helper for now. (or declare LegendLayout as friend)
                 LegendMarkerItem* item() const { return m_item; }
                 virtual QAbstractSeries* series() = 0;
                 virtual QObject* relatedObject() = 0;
                 void invalidateLegend();
             public Q_SLOTS:
                 virtual void updated() = 0;
             protected:
                 LegendMarkerItem *m_item;
                 QLegend *m_legend;
                 bool m_customLabel;
                 bool m_customBrush;
                 bool m_customPen;
             private:
                 QLegendMarker *q_ptr;
                 friend class QLegendPrivate;
                 friend class LegendMarkerItem;
                 Q_DECLARE_PUBLIC(QLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGENDMARKERPRIVATE_H

src/scatterchart/scatterchartitem.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 Enterprise Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Enterprise licenses may use this file in
              ** accordance with the Qt Enterprise 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 "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_items(this),
                   m_visible(true),
                   m_shape(QScatterSeries::MarkerShapeRectangle),
                   m_size(15)
             {
                 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()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                     case QScatterSeries::MarkerShapeCircle: {
                         item = new CircleMarker(0, 0, m_size, m_size, this);
                         const QRectF &rect = item->boundingRect();
                         item->setPos(-rect.width() / 2, -rect.height() / 2);
                         break;
                     }
                     case QScatterSeries::MarkerShapeRectangle:
                         item = new RectangleMarker(0, 0, m_size, m_size, this);
                         item->setPos(-m_size / 2, -m_size / 2);
                         break;
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
             }
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
                 emit XYChart::clicked(m_markerMap[marker]);
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
                 emit XYChart::hovered(m_markerMap[marker], state);
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if (points.size() == 0) {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if (diff > 0)
                     deletePoints(diff);
                 else if (diff < 0)
                     createPoints(-diff);
                 if (diff != 0)
                     handleUpdated();
                 QList<QGraphicsItem *> items = m_items.childItems();
                 QRectF clipRect(QPointF(0,0),domain()->size());
                 QVector<bool> offGridStatus = offGridStatusVector();
                 const int seriesLastIndex = m_series->count() - 1;
                 for (int i = 0; i < points.size(); i++) {
                     QGraphicsItem *item = items.at(i);
                     const QPointF &point = points.at(i);
                     const QRectF &rect = item->boundingRect();
                     // During remove animation series may have different number of points,
                     // so ensure we don't go over the index. Animation handling itself ensures that
                     // if there is actually no points in the series, then it won't generate a fake point,
                     // so we can be assured there is always at least one point in m_series here.
                     // Note that marker map values can be technically incorrect during the animation,
                     // if it was caused by an insert, but this shouldn't be a problem as the points are
                     // fake anyway. After remove animation stops, geometry is updated to correct one.
                     m_markerMap[item] = m_series->at(qMin(seriesLastIndex, i));
                     item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
                     if (!m_visible || offGridStatus.at(i))
                         item->setVisible(false);
                     else
                         item->setVisible(true);
                 }
                 prepareGeometryChange();
                 m_rect = clipRect;
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
             void ScatterChartItem::setBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if (count == 0)
                     return;
                 bool recreate = m_visible != m_series->isVisible()
                                 || m_size != m_series->markerSize()
                                 || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 setOpacity(m_series->opacity());
                 if (recreate) {
-                    // TODO: optimize handleUpdate to recreate points only in case shape changed
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart.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 Enterprise Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Enterprise licenses may use this file in
              ** accordance with the Qt Enterprise 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 "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include "qxymodelmapper.h"
             #include "qabstractaxis_p.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
                   ChartItem(series->d_func(),item),
                   m_series(series),
                   m_animation(0),
                   m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF> &points)
             {
                 m_points = points;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             // Returns a vector with same size as geometryPoints vector, indicating
             // the off grid status of points.
             QVector<bool> XYChart::offGridStatusVector()
             {
                 qreal minX = domain()->minX();
                 qreal maxX = domain()->maxX();
                 qreal minY = domain()->minY();
                 qreal maxY = domain()->maxY();
                 QVector<bool> returnVector;
                 returnVector.resize(m_points.size());
                 // During remove animation series may have different number of points,
                 // so ensure we don't go over the index. No need to check for zero points, this
                 // will not be called in such a situation.
                 const int seriesLastIndex = m_series->count() - 1;
                 for (int i = 0; i < m_points.size(); i++) {
                     const QPointF &seriesPoint = m_series->at(qMin(seriesLastIndex, i));
                     if (seriesPoint.x() < minX
                         || seriesPoint.x() > maxX
                         || seriesPoint.y() < minY
                         || seriesPoint.y() > maxY) {
                         returnVector[i] = true;
                     } else {
                         returnVector[i] = false;
                     }
                 }
                 return returnVector;
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 } else {
                     m_points = newPoints;
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty || m_points.isEmpty()) {
                     points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
                     points = m_points;
                     QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
                     if (!m_validData)
                         m_points.clear();
                     else
                         points.insert(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointRemoved(int index)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty || m_points.isEmpty()) {
                     points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
                     points = m_points;
                     points.remove(index);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty || m_points.isEmpty()) {
                     points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
                     QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
                     if (!m_validData)
                         m_points.clear();
                     points = m_points;
                     if (m_validData)
                         points.replace(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointsReplaced()
             {
                 // All the points were replaced -> recalculate
                 QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
                 updateChart(m_points, points, -1);
             }
             void XYChart::handleDomainUpdated()
             {
                 if (isEmpty()) return;
                 QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
                 updateChart(m_points, points);
             }
             bool XYChart::isEmpty()
             {
                 return domain()->isEmpty() || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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