HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2539:74f3dbde7a75

Added HTML support for various text items...

Miikka Heikkinen -

r2539:74f3dbde7a75

parent child

Context file:

r2539:74f3dbde7a75

Expand all files

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +2 -2

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include "abstractchartlayout_p.h"
             #include <QDebug>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, QGraphicsItem* item)
                 : HorizontalAxis(axis, item, true),
                   m_categoriesAxis(axis)
             {
                 QObject::connect(m_categoriesAxis,SIGNAL(categoriesChanged()),this, SLOT(handleCategoriesChanged()));
                 handleCategoriesChanged();
             }
             ChartBarCategoryAxisX::~ChartBarCategoryAxisX()
             {
             }
             QVector<qreal> ChartBarCategoryAxisX::calculateLayout() const
             {
                 QVector<qreal> points;
                 const QRectF& gridRect = gridGeometry();
                 qreal range = max() - min();
                 const qreal delta = gridRect.width() / range;
                 if (delta < 2)
                     return points;
                 qreal adjustedMin = min() + 0.5;
                 qreal offset = (ceil(adjustedMin) - adjustedMin) * delta;
                 int count = qFloor(range);
                 if (count < 1)
                     return points;
                 points.resize(count + 2);
                 for (int i = 0; i < count + 2; ++i)
                     points[i] = offset + (qreal(i) * delta) + gridRect.left();
                 return points;
             }
             QStringList ChartBarCategoryAxisX::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result ;
                 const QRectF &gridRect = gridGeometry();
                 qreal d = (max() - min()) / gridRect.width();
                 for (int i = 0; i < layout.count() - 1; ++i) {
                     qreal x = qFloor((((layout[i] + layout[i + 1]) / 2 - gridRect.left()) * d + min() + 0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     } else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartBarCategoryAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createCategoryLabels(layout));
                 HorizontalAxis::updateGeometry();
             }
             void ChartBarCategoryAxisX::handleCategoriesChanged()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();
                 qreal width = 0; // Width is irrelevant for X axes with interval labels
                 qreal height = 0;
                 switch (which) {
                     case Qt::MinimumSize: {
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                        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 = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                            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;
             }
             #include "moc_chartbarcategoryaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +2 -2

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, QGraphicsItem* item)
                 : VerticalAxis(axis, item, true),
                   m_categoriesAxis(axis)
             {
                 QObject::connect( m_categoriesAxis,SIGNAL(categoriesChanged()),this, SLOT(handleCategoriesChanged()));
                 handleCategoriesChanged();
             }
             ChartBarCategoryAxisY::~ChartBarCategoryAxisY()
             {
             }
             QVector<qreal> ChartBarCategoryAxisY::calculateLayout() const
             {
                 QVector<qreal> points;
                 const QRectF& gridRect = gridGeometry();
                 qreal range = max() - min();
                 const qreal delta = gridRect.height() / range;
                 if (delta < 2)
                     return points;
                 qreal adjustedMin = min() + 0.5;
                 qreal offset = (ceil(adjustedMin) - adjustedMin) * delta;
                 int count = qFloor(range);
                 if (count < 1)
                     return points;
                 points.resize(count + 2);
                 for (int i = 0; i < count + 2; ++i)
                     points[i] =  gridRect.bottom() - (qreal(i) * delta) - offset;
                 return points;
             }
             QStringList ChartBarCategoryAxisY::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
                 const QRectF &gridRect = gridGeometry();
                 qreal d = (max() - min()) / gridRect.height();
                 for (int i = 0; i < layout.count() - 1; ++i) {
                     qreal x = qFloor(((gridRect.height() - (layout[i + 1] + layout[i]) / 2 + gridRect.top()) * d + min() + 0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     } else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartBarCategoryAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createCategoryLabels(layout));
                 VerticalAxis::updateGeometry();
             }
             void ChartBarCategoryAxisY::handleCategoriesChanged()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();
                 qreal width = 0;
                 qreal height = 0; // Height is irrelevant for Y axes with interval labels
                 switch (which) {
                     case Qt::MinimumSize: {
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                        QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                         width = boundingRect.width() + labelPadding() + base.width() + 1.0;
                         if (base.width() > 0.0)
                             width += labelPadding();
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize:{
                         qreal labelWidth = 0.0;
                         foreach (const QString& s, ticksList) {
-                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                            QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelWidth = qMax(rect.width(), labelWidth);
                         }
                         width = labelWidth + labelPadding() + base.width() + 1.0;
                         if (base.width() > 0.0)
                             width += labelPadding();
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                       break;
                   }
                   return sh;
             }
             #include "moc_chartbarcategoryaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/cartesianchartaxis.cpp +5 -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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "cartesianchartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "abstractdomain_p.h"
             #include "linearrowitem_p.h"
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             CartesianChartAxis::CartesianChartAxis(QAbstractAxis *axis, QGraphicsItem *item , bool intervalAxis)
                 : ChartAxisElement(axis, item, intervalAxis)
             {
                 Q_ASSERT(item);
             }
             CartesianChartAxis::~CartesianChartAxis()
             {
             }
             void CartesianChartAxis::createItems(int count)
             {
                 if (arrowItems().size() == 0) {
                     QGraphicsLineItem *arrow = new LineArrowItem(this, this);
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 if (intervalAxis() && gridItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem *item = new QGraphicsLineItem(this);
                         item->setPen(axis()->gridLinePen());
                         gridGroup()->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(this);
                     QGraphicsLineItem *grid = new QGraphicsLineItem(this);
-                    QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
+                    QGraphicsTextItem *label = new QGraphicsTextItem(this);
-                    QGraphicsSimpleTextItem *title = titleItem();
+                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
-                    label->setPen(axis()->labelsPen());
+                    label->setDefaultTextColor(axis()->labelsBrush().color());
-                    label->setBrush(axis()->labelsBrush());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
-                    title->setPen(axis()->titlePen());
+                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setBrush(axis()->titleBrush());
+                    title->setHtml(axis()->titleText());
-                    title->setText(axis()->titleText());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if ((gridItems().size()) % 2 && gridItems().size() > 2) {
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
             }
             void CartesianChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void CartesianChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = ChartAxisElement::layout().size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (animation()) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         animation()->setAnimationType(AxisAnimation::ZoomInAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         animation()->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         animation()->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         animation()->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         animation()->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     animation()->setValues(ChartAxisElement::layout(), layout);
                     presenter()->startAnimation(animation());
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             bool CartesianChartAxis::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             void CartesianChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 setAxisGeometry(axis);
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             QSizeF CartesianChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             void CartesianChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void CartesianChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             #include "moc_cartesianchartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisx.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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 = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    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 = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        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/categoryaxis/chartcategoryaxisy.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartcategoryaxisy_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis, QGraphicsItem* item)
                 : VerticalAxis(axis, item, true),
                   m_axis(axis)
             {
                 QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
             }
             ChartCategoryAxisY::~ChartCategoryAxisY()
             {
             }
             QVector<qreal> ChartCategoryAxisY::calculateLayout() const
             {
                 int tickCount = m_axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 const QRectF &gridRect = gridGeometry();
                 qreal range = max() - min();
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.height() / range;
                     for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             qreal y = -(m_axis->startValue(m_axis->categoriesLabels().at(i)) - min()) * scale + gridRect.bottom();
                             points[i] = y;
                         } else {
                             qreal y = -(m_axis->endValue(m_axis->categoriesLabels().at(i - 1)) - min())  * scale + gridRect.bottom();
                             points[i] = y;
                         }
                     }
                 }
                 return points;
             }
             void ChartCategoryAxisY::updateGeometry()
             {
                 setLabels(m_axis->categoriesLabels() << "");
                 VerticalAxis::updateGeometry();
             }
             QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 qreal width = 0;
                 qreal height = 0; // Height is irrelevant for Y axes with interval labels
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() + labelPadding() + base.width() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelWidth = 0.0;
                     foreach (const QString& s, ticksList) {
-                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                     }
                     width = labelWidth + labelPadding() + base.width() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             void ChartCategoryAxisY::handleCategoriesChanged()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             #include "moc_chartcategoryaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxiselement.cpp +51 -83

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxiselement_p.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QDateTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QGraphicsSimpleTextItem *dummyTextItem = 0;
+            static const char *labelFormatMatchString = "%[\\-\\+#\\s\\d\\.lhjztL]*([dicuoxfegXFEG])";
-            class StaticDeleter
+            static QRegExp *labelFormatMatcher = 0;
+            class StaticLabelFormatMatcherDeleter
             {
             public:
-                StaticDeleter() {}
+                StaticLabelFormatMatcherDeleter() {}
-                ~StaticDeleter() { delete dummyTextItem; }
+                ~StaticLabelFormatMatcherDeleter() { delete labelFormatMatcher; }
             };
-            StaticDeleter staticDeleter;
+            StaticLabelFormatMatcherDeleter staticLabelFormatMatcherDeleter;
             ChartAxisElement::ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_animation(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
-                  m_title(new QGraphicsSimpleTextItem(item)),
+                  m_title(new QGraphicsTextItem(item)),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
-                if (!dummyTextItem)
-                    dummyTextItem = new QGraphicsSimpleTextItem;
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 handleVisibleChanged(axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents, true);
             }
             ChartAxisElement::~ChartAxisElement()
             {
             }
             void ChartAxisElement::connectSlots()
             {
                 QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsPenChanged(const QPen&)), this, SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(titlePenChanged(const QPen&)), this, SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
             }
             void ChartAxisElement::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxisElement::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_labels->setVisible(visible);
             }
             void ChartAxisElement::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxisElement::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsPenChanged(const QPen &pen)
             {
-                foreach (QGraphicsItem *item, m_labels->childItems())
+                Q_UNUSED(pen)
-                    static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
-                    static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
+                    static_cast<QGraphicsTextItem *>(item)->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
-                    static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
+                    static_cast<QGraphicsTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
-                m_title->setText(title);
+                m_title->setHtml(title);
             }
             void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
             {
-                m_title->setPen(pen);
+                Q_UNUSED(pen)
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
-                m_title->setBrush(brush);
+                m_title->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleTitleFontChanged(const QFont &font)
             {
                 if (m_title->font() != font) {
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxisElement::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if (!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 } else {
                     m_grid->setVisible(axis()->isGridLineVisible());
                     m_arrow->setVisible(axis()->isLineVisible());
                     m_shades->setVisible(axis()->shadesVisible());
                     m_labels->setVisible(axis()->labelsVisible());
                     m_title->setVisible(axis()->isTitleVisible());
                 }
                 if (presenter()) presenter()->layout()->invalidate();
             }
-            QRectF ChartAxisElement::textBoundingRect(const QFont &font, const QString &text, qreal angle) const
-                dummyTextItem->setFont(font);
-                dummyTextItem->setText(text);
-                QRectF boundingRect = dummyTextItem->boundingRect();
-                // Take rotation into account
-                if (angle) {
-                    QTransform transform;
-                    transform.rotate(angle);
-                    boundingRect = transform.mapRect(boundingRect);
-                return boundingRect;
-            // boundingRect parameter returns the rotated bounding rect of the text
-            QString ChartAxisElement::truncatedText(const QFont &font, const QString &text, qreal angle,
-                                                    qreal maxSize, Qt::Orientation constraintOrientation,
-                                                    QRectF &boundingRect) const
-                QString truncatedString(text);
-                boundingRect = textBoundingRect(font, truncatedString, angle);
-                qreal checkDimension = ((constraintOrientation == Qt::Horizontal)
-                                       ? boundingRect.width() : boundingRect.height());
-                if (checkDimension > maxSize) {
-                    truncatedString.append("...");
-                    while (checkDimension > maxSize && truncatedString.length() > 3) {
-                        truncatedString.remove(truncatedString.length() - 4, 1);
-                        boundingRect = textBoundingRect(font, truncatedString, angle);
-                        checkDimension = ((constraintOrientation == Qt::Horizontal)
-                                         ? boundingRect.width() : boundingRect.height());
-                return truncatedString;
             void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         // We don't want to call invalidate on layout, since it will change minimum size of
                         // component, which we would like to avoid since it causes nasty flips when scrolling
                         // or zooming, instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             bool ChartAxisElement::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             qreal ChartAxisElement::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxisElement::max() const
             {
                 return m_axis->d_ptr->max();
             }
+            static void appendFormattedLabel(const QString &capStr, const QByteArray &array,
+                                             QStringList &labels, qreal value)
+            {
+                if (capStr.isEmpty()) {
+                    labels << QString();
+                } else if (capStr.at(0) == QLatin1Char('d')
+                    || capStr.at(0) == QLatin1Char('i')
+                    || capStr.at(0) == QLatin1Char('c')) {
+                    labels << QString().sprintf(array, (qint64)value);
+                } else if (capStr.at(0) == QLatin1Char('u')
+                         || capStr.at(0) == QLatin1Char('o')
+                         || capStr.at(0) == QLatin1Char('x')
+                         || capStr.at(0) == QLatin1Char('X')) {
+                    labels << QString().sprintf(array, (quint64)value);
+                } else if (capStr.at(0) == QLatin1Char('f')
+                           || capStr.at(0) == QLatin1Char('F')
+                           || capStr.at(0) == QLatin1Char('e')
+                           || capStr.at(0) == QLatin1Char('E')
+                           || capStr.at(0) == QLatin1Char('g')
+                           || capStr.at(0) == QLatin1Char('G')) {
+                    labels << QString().sprintf(array, value);
+                } else {
+                    labels << QString();
+                }
+            }
             QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks, const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
+                    QString capStr;
+                    if (!labelFormatMatcher)
+                        labelFormatMatcher = new QRegExp(labelFormatMatchString);
+                    if (labelFormatMatcher->indexIn(format, 0) != -1)
+                        capStr = labelFormatMatcher->cap(1);
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
-                        if (format.contains("d")
+                        appendFormattedLabel(capStr, array, labels, value);
-                            || format.contains("i")
-                            || format.contains("c")) {
-                            labels << QString().sprintf(array, (qint64)value);
-                        } else if (format.contains("u")
-                                 || format.contains("o")
-                                 || format.contains("x", Qt::CaseInsensitive)) {
-                            labels << QString().sprintf(array, (quint64)value);
-                        } else if (format.contains("f", Qt::CaseInsensitive)
-                                 || format.contains("e", Qt::CaseInsensitive)
-                                 || format.contains("g", Qt::CaseInsensitive)) {
-                            labels << QString().sprintf(array, value);
-                        } else {
-                            labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = 0;
                 if (ticks > 1)
                     n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
+                    QString capStr;
+                    if (!labelFormatMatcher)
+                        labelFormatMatcher = new QRegExp(labelFormatMatchString);
+                    if (labelFormatMatcher->indexIn(format, 0) != -1)
+                        capStr = labelFormatMatcher->cap(1);
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
-                        if (format.contains("d")
+                        appendFormattedLabel(capStr, array, labels, value);
-                            || format.contains("i")
-                            || format.contains("c")) {
-                            labels << QString().sprintf(array, (qint64)value);
-                        } else if (format.contains("u")
-                                 || format.contains("o")
-                                 || format.contains("x", Qt::CaseInsensitive)) {
-                            labels << QString().sprintf(array, (quint64)value);
-                        } else if (format.contains("f", Qt::CaseInsensitive)
-                                 || format.contains("e", Qt::CaseInsensitive)
-                                 || format.contains("g", Qt::CaseInsensitive)) {
-                            labels << QString().sprintf(array, value);
-                        } else {
-                            labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxiselement_p.h +2 -6

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTAXISELEMENT_H
             #define CHARTAXISELEMENT_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractAxis;
             class ChartAxisElement : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
             public:
                 ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~ChartAxisElement();
                 virtual QRectF gridGeometry() const = 0;
                 virtual void setGeometry(const QRectF &axis, const QRectF &grid) = 0;
                 virtual bool isEmpty() = 0;
                 void setAnimation(AxisAnimation *animation) { m_animation = animation; }
                 AxisAnimation *animation() const { return m_animation; }
                 QAbstractAxis *axis() const { return m_axis; }
                 void setLayout(QVector<qreal> &layout) { m_layout = layout; }
                 QVector<qreal> &layout() { return m_layout; } // Modifiable reference
                 int labelPadding() const { return 5; }
                 int titlePadding() const { return 3; }
                 void setLabels(const QStringList &labels) { m_labelsList = labels; }
                 QStringList labels() const { return m_labelsList; }
                 qreal min() const;
                 qreal max() const;
                 QRectF axisGeometry() const { return m_axisRect; }
                 void setAxisGeometry(const QRectF &axisGeometry) { m_axisRect = axisGeometry; }
-                QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0) const;
-                QString truncatedText(const QFont &font, const QString &text, qreal angle, qreal maxSize,
-                                      Qt::Orientation constraintOrientation, QRectF &boundingRect) const;
                 void axisSelected();
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
                 static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format);
                 static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
                 // from QGraphicsLayoutItem
                 QRectF boundingRect() const
                 {
                     return QRectF();
                 }
                 // from QGraphicsLayoutItem
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             protected:
                 virtual QVector<qreal> calculateLayout() const = 0;
                 virtual void updateLayout(QVector<qreal> &layout) = 0;
                 QList<QGraphicsItem *> gridItems() { return m_grid->childItems(); }
                 QList<QGraphicsItem *> labelItems() { return m_labels->childItems(); }
                 QList<QGraphicsItem *> shadeItems() { return m_shades->childItems(); }
                 QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems(); }
-                QGraphicsSimpleTextItem *titleItem() const { return m_title.data(); }
+                QGraphicsTextItem *titleItem() const { return m_title.data(); }
                 QGraphicsItemGroup *gridGroup() { return m_grid.data(); }
                 QGraphicsItemGroup *labelGroup() { return m_labels.data(); }
                 QGraphicsItemGroup *shadeGroup() { return m_shades.data(); }
                 QGraphicsItemGroup *arrowGroup() { return m_arrow.data(); }
             public Q_SLOTS:
                 void handleVisibleChanged(bool visible);
                 void handleArrowVisibleChanged(bool visible);
                 void handleGridVisibleChanged(bool visible);
                 void handleLabelsVisibleChanged(bool visible);
                 void handleShadesVisibleChanged(bool visible);
                 void handleLabelsAngleChanged(int angle);
                 virtual void handleShadesBrushChanged(const QBrush &brush) = 0;
                 virtual void handleShadesPenChanged(const QPen &pen) = 0;
                 virtual void handleArrowPenChanged(const QPen &pen) = 0;
                 virtual void handleGridPenChanged(const QPen &pen) = 0;
                 void handleLabelsPenChanged(const QPen &pen);
                 void handleLabelsBrushChanged(const QBrush &brush);
                 void handleLabelsFontChanged(const QFont &font);
                 void handleTitlePenChanged(const QPen &pen);
                 void handleTitleBrushChanged(const QBrush &brush);
                 void handleTitleFontChanged(const QFont &font);
                 void handleTitleTextChanged(const QString &title);
                 void handleTitleVisibleChanged(bool visible);
                 void handleRangeChanged(qreal min, qreal max);
             Q_SIGNALS:
                 void clicked();
             private:
                 void connectSlots();
                 QAbstractAxis *m_axis;
                 AxisAnimation *m_animation;
                 QVector<qreal> m_layout;
                 QStringList m_labelsList;
                 QRectF m_axisRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
-                QScopedPointer<QGraphicsSimpleTextItem> m_title;
+                QScopedPointer<QGraphicsTextItem> m_title;
                 bool m_intervalAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXISELEMENT_H */

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdatetimeaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QDateTime>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, QGraphicsItem *item)
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
             }
             ChartDateTimeAxisX::~ChartDateTimeAxisX()
             {
             }
             QVector<qreal> ChartDateTimeAxisX::calculateLayout() const
             {
                 int tickCount = m_axis->tickCount();
                 Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / (qreal(tickCount) - 1.0);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] =  qreal(i) * deltaX + gridRect.left();
                 return points;
             }
             void ChartDateTimeAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createDateTimeLabels(min(), max(), layout.size(), m_axis->format()));
                 HorizontalAxis::updateGeometry();
             }
             void ChartDateTimeAxisX::handleTickCountChanged(int tick)
             {
                 Q_UNUSED(tick)
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter())
                     presenter()->layout()->invalidate();
             }
             void ChartDateTimeAxisX::handleFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter())
                     presenter()->layout()->invalidate();
             }
             QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createDateTimeLabels(min(), max(), m_axis->tickCount(), m_axis->format());
                 // Width of horizontal axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base width is irrelevant.
                 qreal width = 0;
                 qreal height = 0;
                 if (ticksList.empty())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() / 2.0;
                     height = boundingRect.height() + labelPadding() + base.height() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelHeight = 0.0;
                     qreal firstWidth = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                         width = rect.width();
                         if (firstWidth < 0.0)
                             firstWidth = width;
                     }
                     height = labelHeight + labelPadding() + base.height() + 1.0;
                     width = qMax(width, firstWidth) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartdatetimeaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdatetimeaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QDateTime>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
             }
             ChartDateTimeAxisY::~ChartDateTimeAxisY()
             {
             }
             QVector<qreal> ChartDateTimeAxisY::calculateLayout() const
             {
                 int tickCount = m_axis->tickCount();
                 Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / (qreal(tickCount) - 1.0);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] =  qreal(i) * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartDateTimeAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createDateTimeLabels(min(), max(), layout.size(), m_axis->format()));
                 VerticalAxis::updateGeometry();
             }
             void ChartDateTimeAxisY::handleTickCountChanged(int tick)
             {
                 Q_UNUSED(tick)
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter())
                     presenter()->layout()->invalidate();
             }
             void ChartDateTimeAxisY::handleFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter())
                     presenter()->layout()->invalidate();
             }
             QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createDateTimeLabels(min(), max(), m_axis->tickCount(), m_axis->format());
                 qreal width = 0;
                 // Height of vertical axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base height is irrelevant.
                 qreal height = 0;
                 if (ticksList.empty())
                     return sh;
                 switch (which) {
                     case Qt::MinimumSize: {
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                        QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                         width = boundingRect.width() + labelPadding() + base.width() + 1.0;
                         height = boundingRect.height() / 2.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize: {
                         qreal labelWidth = 0.0;
                         qreal firstHeight = -1.0;
                         foreach (const QString& s, ticksList) {
-                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                            QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelWidth = qMax(rect.width(), labelWidth);
                             height = rect.height();
                             if (firstHeight < 0.0)
                                 firstHeight = height;
                         }
                         width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
                         height = qMax(height, firstHeight) / 2.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartdatetimeaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/horizontalaxis.cpp +8 -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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalaxis_p.h"
             #include "qabstractaxis_p.h"
+            #include "chartpresenter_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
-                QGraphicsSimpleTextItem *title = titleItem();
+                QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(arrow.at(0));
                 if (axis()->alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
                 else if (axis()->alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
-                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, gridRect.width(), Qt::Horizontal, QRectF()));
+                    title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), gridRect.width(), Qt::Horizontal, QRectF()));
                     titlePad = titlePadding();
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignTop) {
                         title->setPos(center.x(), axisRect.top() + titlePad);
                     } else  if (axis()->alignment() == Qt::AlignBottom) {
                         title->setPos(center.x(), axisRect.bottom() - titleBoundingRect.height() - titlePad);
                     }
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(arrow.at(i + 1));
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
+                    QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
                     //label text wrapping
                     QString text = labelList.at(i);
                     QRectF boundingRect;
                     qreal size = axisRect.bottom() - axisRect.top() - labelPadding() - titleBoundingRect.height() - (titlePad * 2);
-                    labelItem->setText(truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
+                    labelItem->setHtml(ChartPresenter::truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
-                                                     size, Qt::Vertical, boundingRect));
+                                                                     size, Qt::Vertical, boundingRect));
                     //label transformation origin point
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     int heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
                     if (axis()->alignment() == Qt::AlignTop) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() + (heightDiff / 2) - labelPadding());
                         tickItem->setLine(layout[i], axisRect.bottom(), layout[i], axisRect.bottom() - labelPadding());
                     } else if (axis()->alignment() == Qt::AlignBottom) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2) + labelPadding());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
                     //label in between
                     bool forceHide = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
                         qreal leftBound = qMax(layout[i], gridRect.left());
                         qreal rightBound = qMin(layout[i + 1], gridRect.right());
                         const qreal delta = rightBound - leftBound;
                         // Hide label in case visible part of the category at the grid edge is too narrow
                         if (delta < boundingRect.width()
                             && (leftBound == gridRect.left() || rightBound == gridRect.right())) {
                             forceHide = true;
                         } else {
                             labelItem->setPos(leftBound + (delta / 2.0) - center.x(), labelItem->pos().y());
                         }
                     }
                     //label overlap detection - compensate one pixel for rounding errors
                     if (labelItem->pos().x() < width || forceHide ||
                         labelItem->pos().x() < (axisRect.left() - 1.0) ||
                         (labelItem->pos().x() + boundingRect.width() - 1.0) > axisRect.right()){
                         labelItem->setVisible(false);
                     } else {
                         labelItem->setVisible(true);
                         width = boundingRect.width() + labelItem->pos().x();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         qreal leftBound = qMax(layout[i - 1], gridRect.left());
                         qreal rightBound = qMin(layout[i], gridRect.right());
                         rectItem->setRect(leftBound, gridRect.top(), rightBound - leftBound, gridRect.height());
                         if (rectItem->rect().width() <= 0.0)
                             rectItem->setVisible(false);
                         else
                             rectItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal x = gridItem->line().p1().x();
                     if (x < gridRect.left() || x > gridRect.right()) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     } else {
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.right(), gridRect.top(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.left(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF HorizontalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0,0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF titleRect = textBoundingRect(axis()->titleFont(), "...");
+                    QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), "...");
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2));
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
-                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
+                    QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2));
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisx.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem *item)
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
                 QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisX::~ChartLogValueAxisX()
             {
             }
             QVector<qreal> ChartLogValueAxisX::calculateLayout() const
             {
                 QVector<qreal> points;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
                 qreal ceilEdge = ceil(leftEdge);
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = (ceilEdge + qreal(i)) * deltaX - leftEdge * deltaX + gridRect.left();
                 return points;
             }
             void ChartLogValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
                 HorizontalAxis::updateGeometry();
             }
             void ChartLogValueAxisX::handleBaseChanged(qreal base)
             {
                 Q_UNUSED(base);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartLogValueAxisX::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartLogValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 0)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
                 // Width of horizontal axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base width is irrelevant.
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize:{
-                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() / 2.0;
                     height = boundingRect.height() + labelPadding() + base.height() + 1.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelHeight = 0.0;
                     qreal firstWidth = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                         width = rect.width();
                         if (firstWidth < 0.0)
                             firstWidth = width;
                     }
                     height = labelHeight + labelPadding() + base.height() + 1.0;
                     width = qMax(width, firstWidth) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisy.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
                 QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisY::~ChartLogValueAxisY()
             {
             }
             QVector<qreal> ChartLogValueAxisY::calculateLayout() const
             {
                 QVector<qreal> points;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
                 qreal ceilEdge = ceil(leftEdge);
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = (ceilEdge + qreal(i)) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartLogValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
                 VerticalAxis::updateGeometry();
             }
             void ChartLogValueAxisY::handleBaseChanged(qreal base)
             {
                 Q_UNUSED(base);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartLogValueAxisY::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartLogValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 0)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
                 qreal width = 0;
                 // Height of vertical axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base height is irrelevant.
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() + labelPadding() + base.width() + 1.0;
                     height = boundingRect.height() / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelWidth = 0.0;
                     qreal firstHeight = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                         height = rect.height();
                         if (firstHeight < 0.0)
                             firstHeight = height;
                     }
                     width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
                     height = qMax(height, firstHeight) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisangular.cpp +12 -14

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartaxisangular_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include <QDebug>
             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();
-                QGraphicsSimpleTextItem *title = titleItem();
+                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));
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labelItemList.at(i));
+                    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->setText(labelList.at(i));
+                        labelItem->setHtml(labelList.at(i));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
+                        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()) {
-                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, axisGeometry().width(), Qt::Horizontal, QRectF()));
+                    title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), axisGeometry().width(), Qt::Horizontal, QRectF()));
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = center - titleBoundingRect.center();
                     title->setPos(titleCenter.x(), axisGeometry().top() - qreal(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());
-                    QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
+                    QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
-                    QGraphicsSimpleTextItem *title = titleItem();
+                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
-                    label->setPen(axis()->labelsPen());
+                    label->setDefaultTextColor(axis()->labelsBrush().color());
-                    label->setBrush(axis()->labelsBrush());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
-                    title->setPen(axis()->titlePen());
+                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setBrush(axis()->titleBrush());
+                    title->setHtml(axis()->titleText());
-                    title->setText(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 = textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
+                        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);
                         if (boundingRect.isEmpty() || maxRect.intersected(boundingRect) == boundingRect) {
                             i++;
                         } else {
                             radius -= 1.0;
                             if (radius < 1.0) // safeguard
                                 return 1.0;
                         }
                     }
                 }
                 if (!axis()->titleText().isEmpty() && axis()->isTitleVisible()) {
-                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
+                    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/polarchartaxisradial.cpp +10 -12

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartaxisradial_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qabstractaxis_p.h"
             #include "linearrowitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PolarChartAxisRadial::PolarChartAxisRadial(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisRadial::~PolarChartAxisRadial()
             {
             }
             void PolarChartAxisRadial::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();
-                QGraphicsSimpleTextItem* title = titleItem();
+                QGraphicsTextItem* title = titleItem();
                 qreal radius = axisGeometry().height() / 2.0;
                 QLineF line(center, center + QPointF(0, -radius));
                 QGraphicsLineItem *axisLine = static_cast<QGraphicsLineItem *>(arrowItemList.at(0));
                 axisLine->setLine(line);
                 QRectF previousLabelRect;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > radius);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal radialCoordinate = layout.at(i);
                     QGraphicsEllipseItem *gridItem = static_cast<QGraphicsEllipseItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labelItemList.at(i));
+                    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) > radius) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = radialCoordinate;
                     qreal labelVisible = currentTickVisible;
                     qreal labelPad = labelPadding() / 2.0;
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = radius;
                         else
                             farEdge = qMin(radius, 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 < radius)
                             labelVisible =  true;
                         else
                             labelVisible = false;
                     }
                     // Radial axis label
                     if (axis()->labelsVisible() && labelVisible) {
-                        labelItem->setText(labelList.at(i));
+                        labelItem->setHtml(labelList.at(i));
                         QRectF labelRect = labelItem->boundingRect();
                         QPointF labelCenter = labelRect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
+                        QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(labelRect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint = center;
                         if (intervalAxis())
                             labelPoint += QPointF(labelPad, -labelCoordinate - (boundingRect.height() / 2.0));
                         else
                             labelPoint += QPointF(labelPad, labelPad - labelCoordinate);
                         labelRect.moveTopLeft(labelPoint);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Label overlap detection
                         labelRect.setSize(boundingRect.size());
                         if ((i && previousLabelRect.intersects(labelRect))
                              || !axisGeometry().contains(labelRect)) {
                             labelVisible = false;
                         } else {
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Radial grid line
                     QRectF gridRect;
                     gridRect.setWidth(radialCoordinate * 2.0);
                     gridRect.setHeight(radialCoordinate * 2.0);
                     gridRect.moveCenter(center);
                     gridItem->setRect(gridRect);
                     gridItem->setVisible(true);
                     // Tick
                     QLineF tickLine(-tickWidth(), 0.0, tickWidth(), 0.0);
                     tickLine.translate(center.rx(), gridRect.top());
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the inner circle
                             // or it won't get filled.
                             QRectF innerCircle(0.0, 0.0, layout.at(0) * 2.0, layout.at(0) * 2.0);
                             innerCircle.moveCenter(center);
                             path.addEllipse(innerCircle);
                         } else {
                             QRectF otherGridRect;
                             if (!nextTickVisible) { // Last visible tick
                                 otherGridRect = axisGeometry();
                             } else {
                                 qreal otherGridRectDimension = layout.at(i + 1) * 2.0;
                                 otherGridRect.setWidth(otherGridRectDimension);
                                 otherGridRect.setHeight(otherGridRectDimension);
                                 otherGridRect.moveCenter(center);
                             }
                             path.addEllipse(gridRect);
                             path.addEllipse(otherGridRect);
                             // Add additional shading in first visible shade item if there is a partial tick
                             // to be filled at the center (log & category axes)
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QRectF innerCircle(0.0, 0.0, layout.at(i - 1) * 2.0, layout.at(i - 1) * 2.0);
                                     innerCircle.moveCenter(center);
                                     QPainterPath specialPath;
                                     specialPath.addEllipse(innerCircle);
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                 }
                 // Title, along the 0 axis
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
-                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, radius, Qt::Horizontal, QRectF()));
+                    title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), radius, Qt::Horizontal, QRectF()));
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = titleBoundingRect.center();
                     QPointF arrowCenter = axisLine->boundingRect().center();
                     QPointF titleCenterDiff = arrowCenter - titleCenter;
                     title->setPos(titleCenterDiff.x() - qreal(titlePadding()) - (titleBoundingRect.height() / 2.0), titleCenterDiff.y());
                     title->setTransformOriginPoint(titleCenter);
                     title->setRotation(270.0);
                 }
                 QGraphicsLayoutItem::updateGeometry();
             }
             Qt::Orientation PolarChartAxisRadial::orientation() const
             {
                 return Qt::Vertical;
             }
             void PolarChartAxisRadial::createItems(int count)
             {
                  if (arrowItems().count() == 0) {
                     // radial axis center line
                     QGraphicsLineItem *arrow = new LineArrowItem(this, presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsEllipseItem *grid = new QGraphicsEllipseItem(presenter()->rootItem());
-                    QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
+                    QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
-                    QGraphicsSimpleTextItem *title = titleItem();
+                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
-                    label->setPen(axis()->labelsPen());
+                    label->setDefaultTextColor(axis()->labelsBrush().color());
-                    label->setBrush(axis()->labelsBrush());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
-                    title->setPen(axis()->titlePen());
+                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setBrush(axis()->titleBrush());
+                    title->setHtml(axis()->titleText());
-                    title->setText(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 PolarChartAxisRadial::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void PolarChartAxisRadial::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
             }
             QSizeF PolarChartAxisRadial::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1.0, -1.0);
             }
             qreal PolarChartAxisRadial::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 return radius;
             }
             #include "moc_polarchartaxisradial_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +8 -16

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #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.
+              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.
+              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.
+              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.
+              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;
             }
-            /*!
-              Sets \a pen used to draw labels.
-            */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
-            /*!
-              Returns the pen used to labels.
-            */
             QPen QAbstractAxis::labelsPen() const
             {
                 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;
             }
-            /*!
-              Sets \a pen used to draw title.
-            */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
-            /*!
-              Returns the pen used to title.
-            */
             QPen QAbstractAxis::titlePen() const
             {
                 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 (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/valueaxis/chartvalueaxisx.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartvalueaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, QGraphicsItem *item )
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartValueAxisX::~ChartValueAxisX()
             {
             }
             QVector<qreal> ChartValueAxisX::calculateLayout() const
             {
             	int tickCount = m_axis->tickCount();
                 Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / (qreal(tickCount) - 1.0);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = qreal(i) * deltaX + gridRect.left();
                 return points;
             }
             void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(min(), max(), layout.size(), m_axis->labelFormat()));
                 HorizontalAxis::updateGeometry();
             }
             void ChartValueAxisX::handleTickCountChanged(int tick)
             {
             	Q_UNUSED(tick);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartValueAxisX::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 // Width of horizontal axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base width is irrelevant.
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                     case Qt::MinimumSize: {
-                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                        QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                         width = boundingRect.width() / 2.0;
                         height = boundingRect.height() + labelPadding() + base.height() + 1.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize: {
                         qreal labelHeight = 0.0;
                         qreal firstWidth = -1.0;
                         foreach (const QString& s, ticksList) {
-                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                            QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelHeight = qMax(rect.height(), labelHeight);
                             width = rect.width();
                             if (firstWidth < 0.0)
                                 firstWidth = width;
                         }
                         height = labelHeight + labelPadding() + base.height() + 1.0;
                         width = qMax(width, firstWidth) / 2.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                         break;
                 }
                 return sh;
             }
             #include "moc_chartvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartvalueaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartValueAxisY::~ChartValueAxisY()
             {
             }
             QVector<qreal> ChartValueAxisY::calculateLayout() const
             {
             	int tickCount = m_axis->tickCount();
                 Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / (qreal(tickCount) - 1.0);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = qreal(i) * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
                 VerticalAxis::updateGeometry();
             }
             void ChartValueAxisY::handleTickCountChanged(int tick)
             {
             	Q_UNUSED(tick);
                 QGraphicsLayoutItem::updateGeometry();
             	if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartValueAxisY::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 // Height of vertical axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base height is irrelevant.
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
+                    QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() + labelPadding() + base.width() + 1.0;
                     height = boundingRect.height() / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelWidth = 0.0;
                     qreal firstHeight = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
+                        QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                         height = rect.height();
                         if (firstHeight < 0.0)
                             firstHeight = height;
                     }
                     width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
                     height = qMax(height, firstHeight) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/verticalaxis.cpp +7 -6

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "verticalaxis_p.h"
             #include "qabstractaxis.h"
+            #include "chartpresenter_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
-                QGraphicsSimpleTextItem *title = titleItem();
+                QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(arrow.at(0));
                 //arrow position
                 if (axis()->alignment() == Qt::AlignLeft)
                     arrowItem->setLine(axisRect.right(), gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if (axis()->alignment() == Qt::AlignRight)
                     arrowItem->setLine(axisRect.left(), gridRect.top(), axisRect.left(), gridRect.bottom());
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
-                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, gridRect.height(), Qt::Horizontal, QRectF()));
+                    title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), gridRect.height(), Qt::Horizontal, QRectF()));
                     titlePad = titlePadding();
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignLeft) {
                         title->setPos(axisRect.left() - titleBoundingRect.width() / 2 + titleBoundingRect.height() / 2 + titlePad, center.y());
                     }
                     else if (axis()->alignment() == Qt::AlignRight) {
                         title->setPos(axisRect.right() - titleBoundingRect.width() / 2 - titleBoundingRect.height() / 2 - titlePad, center.y());
                     }
                     title->setTransformOriginPoint(titleBoundingRect.center());
                     title->setRotation(270);
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrow.at(i + 1));
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
+                    QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
                     //label text wrapping
                     QString text = labelList.at(i);
                     QRectF boundingRect;
                     qreal size = axisRect.right() - axisRect.left() - labelPadding() - titleBoundingRect.height() - (titlePad * 2);
-                    labelItem->setText(truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
+                    labelItem->setHtml(ChartPresenter::truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
                                                      size, Qt::Horizontal, boundingRect));
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     int widthDiff = rect.width() - boundingRect.width();
                     //ticks and label position
                     if (axis()->alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2) - labelPadding(), layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
                     } else if (axis()->alignment() == Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2), layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     //label in between
                     bool forceHide = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
                         qreal lowerBound = qMin(layout[i], gridRect.bottom());
                         qreal upperBound = qMax(layout[i + 1], gridRect.top());
                         const qreal delta = lowerBound - upperBound;
                         // Hide label in case visible part of the category at the grid edge is too narrow
                         if (delta < boundingRect.height()
                             && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                             forceHide = true;
                         } else {
                             labelItem->setPos(labelItem->pos().x() , lowerBound - (delta / 2.0) - center.y());
                         }
                     }
                     //label overlap detection - compensate one pixel for rounding errors
                     if (labelItem->pos().y() + boundingRect.height() > height || forceHide ||
                         (labelItem->pos().y() + (boundingRect.height() / 2.0) - 1.0) > axisRect.bottom() ||
                         labelItem->pos().y() + (boundingRect.height() / 2.0) < (axisRect.top() - 1.0)) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         qreal lowerBound = qMin(layout[i - 1], gridRect.bottom());
                         qreal upperBound = qMax(layout[i], gridRect.top());
                         rectItem->setRect(gridRect.left(), upperBound, gridRect.width(), lowerBound - upperBound);
                         if (rectItem->rect().height() <= 0.0)
                             rectItem->setVisible(false);
                         else
                             rectItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal y = gridItem->line().p1().y();
                     if ((y < gridRect.top() || y > gridRect.bottom()))
                     {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     }else{
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size() + 1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF VerticalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0, 0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    QRectF titleRect = textBoundingRect(axis()->titleFont(), "...");
+                    QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), "...");
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2), titleRect.width());
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
-                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
+                    QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2), titleRect.width());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem.cpp +6 -6

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             #include "baranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
                 handleVisibleChanged();
                 handleUpdatedBars();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 QSizeF size = geometry().size();
                 if (geometry().size().isValid()) {
                     if (m_animation) {
                         if (m_layout.count() == 0 || m_oldSize != size) {
                             initializeLayout();
                             m_oldSize = size;
                         }
                         m_animation->setup(m_layout, layout);
                         presenter()->startAnimation(m_animation);
                     } else {
                         setLayout(layout);
                         update();
                     }
                 }
             }
             void AbstractBarChartItem::setAnimation(BarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i = 0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
-                    QGraphicsSimpleTextItem *label = m_labels.at(i);
+                    QGraphicsTextItem *label = m_labels.at(i);
                     label->setPos(layout.at(i).center() - label->boundingRect().center());
                 }
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 QRectF rect(QPointF(0,0),domain()->size());
                 if(m_rect != rect){
                     prepareGeometryChange();
                     m_rect = rect;
                 }
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0))
                     return; // rect size zero.
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 handleUpdatedBars();
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
-                foreach (QGraphicsSimpleTextItem *label, m_labels)
+                foreach (QGraphicsTextItem *label, m_labels)
                     label->setVisible(visible);
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set, c, this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), m_series, SIGNAL(hovered(bool,QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), set, SIGNAL(hovered(bool)));
                         //            m_layout.append(QRectF(0, 0, 1, 1));
                         // Labels
-                        m_labels.append(new QGraphicsSimpleTextItem(this));
+                        m_labels.append(new QGraphicsTextItem(this));
                     }
                 }
                 if(themeManager()) themeManager()->updateSeries(m_series);
                 handleLayoutChanged();
                 handleVisibleChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 if (visible)
                     handleLabelsVisibleChanged(m_series->isLabelsVisible());
                 else
                     handleLabelsVisibleChanged(visible);
                 foreach (QGraphicsItem *bar, m_bars)
                     bar->setVisible(visible);
             }
             void AbstractBarChartItem::handleOpacityChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     item->setOpacity(m_series->opacity());
             }
             void AbstractBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
-                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
+                        QGraphicsTextItem *label = m_labels.at(itemIndex);
-                        label->setText(QString("%1").arg(barSet->value(category)));
+                        label->setHtml(QString("%1").arg(barSet->value(category)));
                         label->setFont(barSet->m_labelFont);
-                        label->setBrush(barSet->m_labelBrush);
+                        label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef ABSTRACTBARCHARTITEM_H
             #define ABSTRACTBARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qabstractbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
             class BarAnimation;
             class AbstractBarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
                 virtual ~AbstractBarChartItem();
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual QVector<QRectF> calculateLayout() = 0;
                 virtual void initializeLayout() = 0;
                 virtual void applyLayout(const QVector<QRectF> &layout);
                 virtual void setAnimation(BarAnimation *animation);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleDomainUpdated();
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items
                 void handleVisibleChanged();
                 void handleOpacityChanged();
                 virtual void handleUpdatedBars();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
                 BarAnimation *m_animation;
                 QAbstractBarSeries *m_series; // Not owned.
                 QList<Bar *> m_bars;
-                QList<QGraphicsSimpleTextItem *> m_labels;
+                QList<QGraphicsTextItem *> m_labels;
                 QSizeF m_oldSize;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTBARCHARTITEM_H

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalpercentbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
                 : AbstractBarChartItem(series, item)
             {
             }
             void HorizontalPercentBarChartItem::initializeLayout()
             {
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 m_layout.clear();
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
                             topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category + barWidth / 2), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(0, category + barWidth / 2), m_validData);
                         }
                         if (!m_validData)
                              return;
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         m_layout.append(rect.normalized());
                     }
                 }
             }
             QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : domain()->minX(), category - barWidth/2), m_validData);
                         else
                             topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : 0, category - barWidth/2), m_validData);
                         QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(100 * (value + sum)/categorySum, category + barWidth/2), m_validData);
                         if (!m_validData)
                              return QVector<QRectF>();
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                         sum +=value;
                     }
                 }
                 return layout;
             }
             void HorizontalPercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
-                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
+                        QGraphicsTextItem *label = m_labels.at(itemIndex);
                         int p = m_series->d_func()->percentageAt(set, category) * 100;
                         QString vString(QString::number(p));
                         vString.truncate(3);
                         vString.append("%");
-                        label->setText(vString);
+                        label->setHtml(vString);
                         label->setFont(barSet->m_labelFont);
-                        label->setBrush(barSet->m_labelBrush);
+                        label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_horizontalpercentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/percentbarchartitem.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
             }
             void PercentBarChartItem::initializeLayout()
             {
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 m_layout.clear();
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, domain()->minY()), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0), m_validData);
                         }
                         if (!m_validData)
                              return;
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         m_layout.append(rect.normalized());
                     }
                 }
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth/2, 100 * (value + sum)/categorySum), m_validData);
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? 100 * sum/categorySum : domain()->minY()), m_validData);
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? 100 * sum/categorySum : 0), m_validData);
                         if (!m_validData)
                              return QVector<QRectF>();
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                         sum +=value;
                     }
                 }
                 return layout;
             }
             void PercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
-                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
+                        QGraphicsTextItem *label = m_labels.at(itemIndex);
                         int p = m_series->d_func()->percentageAt(set, category) * 100;
                         QString vString(QString::number(p));
                         vString.truncate(3);
                         vString.append("%");
-                        label->setText(vString);
+                        label->setHtml(vString);
                         label->setFont(barSet->m_labelFont);
-                        label->setBrush(barSet->m_labelBrush);
+                        label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +63 -2

             /****************************************************************************
              **
              ** Copyright (C) 2013 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "chartitem_p.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxiselement_p.h"
             #include "chartbackground_p.h"
             #include "cartesianchartlayout_p.h"
             #include "polarchartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            QGraphicsTextItem *dummyTextItem = 0;
+            class StaticDummyTextDeleter
+            {
+            public:
+                StaticDummyTextDeleter() {}
+                ~StaticDummyTextDeleter() { delete dummyTextItem; }
+            };
+            StaticDummyTextDeleter staticDummyTextDeleter;
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
                   m_title(0)
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     m_options = options;
                     foreach(QAbstractSeries* series, m_series){
                         series->d_ptr->initializeAnimations(m_options);
                     }
                     foreach(QAbstractAxis* axis, m_axes){
                         axis->d_ptr->initializeAnimations(m_options);
                     }
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
                     m_background->setBrush(QChartPrivate::defaultBrush());
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createPlotAreaBackgroundItem()
             {
                 if (!m_plotAreaBackground) {
                     if (m_chart->chartType() == QChart::ChartTypeCartesian)
                         m_plotAreaBackground = new QGraphicsRectItem(rootItem());
                     else
                         m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
                     // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
                     // antialising artifacts with axis lines for some reason.
                     m_plotAreaBackground->setPen(QPen(Qt::transparent));
                     m_plotAreaBackground->setBrush(Qt::NoBrush);
                     m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
                     m_plotAreaBackground->setVisible(false);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                 m_animations.removeAll(qobject_cast<ChartAnimation *>(sender()));
                 if (m_animations.empty())
                     emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()), this, SLOT(handleAnimationFinished()), Qt::UniqueConnection);
                 if (!m_animations.isEmpty())
                     m_animations.append(animation);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::plotAreaBackgroundBrush() const
             {
                 if (!m_plotAreaBackground)
                     return QBrush();
                 return m_plotAreaBackground->brush();
             }
             void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::plotAreaBackgroundPen() const
             {
                 if (!m_plotAreaBackground)
                     return QPen();
                 return m_plotAreaBackground->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
-                m_title->setBrush(brush);
+                m_title->setDefaultTextColor(brush.color());
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
-                return m_title->brush();
+                return QBrush(m_title->defaultTextColor());
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setVisible(visible);
             }
             bool ChartPresenter::isPlotAreaBackgroundVisible() const
             {
                 if (!m_plotAreaBackground)
                     return false;
                 return m_plotAreaBackground->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
             {
                 return m_plotAreaBackground;
             }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
+            QRectF ChartPresenter::textBoundingRect(const QFont &font, const QString &text, qreal angle)
+            {
+                if (!dummyTextItem)
+                    dummyTextItem = new QGraphicsTextItem;
+                dummyTextItem->setFont(font);
+                dummyTextItem->setHtml(text);
+                QRectF boundingRect = dummyTextItem->boundingRect();
+                // Take rotation into account
+                if (angle) {
+                    QTransform transform;
+                    transform.rotate(angle);
+                    boundingRect = transform.mapRect(boundingRect);
+                }
+                return boundingRect;
+            }
+            // boundingRect parameter returns the rotated bounding rect of the text
+            QString ChartPresenter::truncatedText(const QFont &font, const QString &text, qreal angle,
+                                                  qreal maxSize, Qt::Orientation constraintOrientation,
+                                                  QRectF &boundingRect)
+            {
+                QString truncatedString(text);
+                boundingRect = textBoundingRect(font, truncatedString, angle);
+                qreal checkDimension = ((constraintOrientation == Qt::Horizontal)
+                                       ? boundingRect.width() : boundingRect.height());
+                if (checkDimension > maxSize) {
+                    truncatedString.append("...");
+                    while (checkDimension > maxSize && truncatedString.length() > 3) {
+                        // Crude truncation logic - simply remove any html tag completely
+                        int removeIndex(-1);
+                        int removeCount(1);
+                        if (truncatedString.at(truncatedString.length() - 4) == QLatin1Char('>')) {
+                            removeIndex = truncatedString.lastIndexOf(QLatin1Char('<'));
+                            if (removeIndex != -1)
+                                removeCount = truncatedString.length() - 3 - removeIndex;
+                        }
+                        if (removeIndex == -1)
+                            removeIndex = truncatedString.length() - 4;
+                        truncatedString.remove(removeIndex, removeCount);
+                        boundingRect = textBoundingRect(font, truncatedString, angle);
+                        checkDimension = ((constraintOrientation == Qt::Horizontal)
+                                         ? boundingRect.width() : boundingRect.height());
+                    }
+                }
+                return truncatedString;
+            }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //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,
                     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 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 Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void animationsFinished();
             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;
                 QList<ChartAnimation *> m_animations;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/charttitle.cpp +14 -22

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttitle_p.h"
+            #include "chartpresenter_p.h"
             #include <QFont>
             #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTitle::ChartTitle(QGraphicsItem *parent)
-                : QGraphicsSimpleTextItem(parent)
+                : QGraphicsTextItem(parent)
             {
             }
             ChartTitle::~ChartTitle()
             {
             }
             void ChartTitle::setText(const QString &text)
             {
                 m_text = text;
             }
             QString ChartTitle::text() const
             {
                 return m_text;
             }
             void ChartTitle::setGeometry(const QRectF &rect)
             {
-                QFontMetrics fn(font());
+                QGraphicsTextItem::setHtml(ChartPresenter::truncatedText(font(), m_text, qreal(0.0), rect.width(), Qt::Horizontal, QRectF()));
-                int width = rect.width();
-                if (fn.boundingRect(m_text).width() > width) {
-                    QString string = m_text + "...";
-                    while (fn.boundingRect(string).width() > width && string.length() > 3)
-                        string.remove(string.length() - 4, 1);
-                    QGraphicsSimpleTextItem::setText(string);
-                } else {
-                    QGraphicsSimpleTextItem::setText(m_text);
                 setPos(rect.topLeft());
             }
             QSizeF ChartTitle::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
-                QFontMetrics fn(font());
                 QSizeF sh;
                 switch (which) {
-                case Qt::MinimumSize:
+                case Qt::MinimumSize: {
-                    sh = QSizeF(fn.boundingRect("...").width(), fn.height());
+                    QRectF titleRect = ChartPresenter::textBoundingRect(font(), "...");
+                    sh = QSizeF(titleRect.width(), titleRect.height());
                     break;
+                }
                 case Qt::PreferredSize:
-                    sh = fn.boundingRect(m_text).size();
+                case Qt::MaximumSize: {
-                    break;
+                    QRectF titleRect = ChartPresenter::textBoundingRect(font(), m_text);
-                case Qt::MaximumSize:
+                    sh = QSizeF(titleRect.width(), titleRect.height());
-                    sh = fn.boundingRect(m_text).size();
                     break;
-                case Qt::MinimumDescent:
+                case Qt::MinimumDescent: {
+                    QFontMetrics fn(font());
                     sh = QSizeF(0, fn.descent());
                     break;
+                }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttitle_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTTITLE_P_H_
             #define CHARTTITLE_P_H_
             #include "qchartglobal.h"
-            #include <QGraphicsSimpleTextItem>
+            #include <QGraphicsTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartTitle : public QGraphicsSimpleTextItem
+            class ChartTitle : public QGraphicsTextItem
             {
             public:
                 ChartTitle(QGraphicsItem *parent = 0);
                 ~ChartTitle();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 void setText(const QString &text);
                 QString text() const;
                 void setGeometry(const QRectF &rect);
             private:
                 QString m_text;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTTITLE_P_H_ */

src/layout/polarchartlayout.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartlayout_p.h"
             #include "chartpresenter_p.h"
             #include "polarchartaxis_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             static const qreal golden_ratio = 0.4;
             PolarChartLayout::PolarChartLayout(ChartPresenter *presenter)
                 : AbstractChartLayout(presenter)
             {
             }
             PolarChartLayout::~PolarChartLayout()
             {
             }
             QRectF PolarChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const
             {
                 // How to handle multiple angular/radial axes?
                 qreal axisRadius = geometry.height() / 2.0;
                 if (geometry.width() < geometry.height())
                     axisRadius = geometry.width() / 2.0;
                 int titleHeight = 0;
                 foreach (ChartAxisElement *chartAxis, axes) {
                     if (!chartAxis->isVisible())
                         continue;
                     PolarChartAxis *polarChartAxis = static_cast<PolarChartAxis *>(chartAxis);
                     qreal radius = polarChartAxis->preferredAxisRadius(geometry.size());
                     if (radius < axisRadius)
                         axisRadius = radius;
                     if (chartAxis->axis()->orientation() == Qt::Horizontal
                         && chartAxis->axis()->isTitleVisible()
                         && !chartAxis->axis()->titleText().isEmpty()) {
                         // If axis has angular title, adjust geometry down by the space title takes
-                        QRectF dummyRect = chartAxis->textBoundingRect(chartAxis->axis()->titleFont(), chartAxis->axis()->titleText());
+                        QRectF dummyRect = ChartPresenter::textBoundingRect(chartAxis->axis()->titleFont(), chartAxis->axis()->titleText());
                         titleHeight = (dummyRect.height() / 2.0) + chartAxis->titlePadding();
                     }
                 }
                 QRectF axisRect;
                 axisRect.setSize(QSizeF(axisRadius * 2.0, axisRadius * 2.0));
                 axisRect.moveCenter(geometry.center());
                 axisRect.adjust(0, titleHeight, 0, titleHeight);
                 foreach (ChartAxisElement *chartAxis, axes)
                     chartAxis->setGeometry(axisRect, QRectF());
                 return axisRect;
             }
             QRectF PolarChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *> &axes) const
             {
                 Q_UNUSED(axes);
                 return minimum;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem.cpp +14 -22

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

src/legend/legendmarkeritem_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef LEGENDMARKERITEM_P_H
             #define LEGENDMARKERITEM_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QFont>
             #include <QBrush>
             #include <QPen>
-            #include <QGraphicsSimpleTextItem>
+            #include <QGraphicsTextItem>
             #include <QGraphicsLayoutItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendMarkerPrivate;
             class LegendMarkerItem : public QGraphicsObject, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 explicit LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent = 0);
                 ~LegendMarkerItem();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setLabel(const QString label);
                 QString label() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setGeometry(const QRectF &rect);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QSizeF sizeHint (Qt::SizeHint which, const QSizeF &constraint) const;
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             protected:
                 QLegendMarkerPrivate *m_marker; // Knows
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
-                QGraphicsSimpleTextItem *m_textItem;
+                QGraphicsTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;
                 qreal m_space;
                 QString m_label;
                 QBrush m_labelBrush;
                 QFont m_font;
                 QPen m_pen;
                 QBrush m_brush;
                 bool m_hovering;
                 QPointF m_pressPos;
                 friend class QLegendMarker;
                 friend class QLegendMarkerPrivate;
                 friend class LegendLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKERITEM_P_H

src/legend/qlegendmarker_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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QLEGENDMARKERPRIVATE_H
             #define QLEGENDMARKERPRIVATE_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
-            #include <QGraphicsSimpleTextItem>
             #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/qabstractseries.cpp +2 -2

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

src/qchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "abstractchartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \enum QChart::ChartType
              This enum describes the chart type.
              \value ChartTypeUndefined
              \value ChartTypeCartesian
              \value ChartTypePolar
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like legend and
              axes. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView, QPolarChart
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Specifies whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              This property is deprecated; use margins property instead.
              \sa margins
              */
             /*!
              \property QChart::margins
              Margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes, and fonts of series, axes, title, and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              \note Changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
-             Title is the name (label) of a chart. It is shown as a headline on top of the chart.
+             Title is the name (label) of a chart. It is shown as a headline on top of the chart. Chart title supports html formatting.
              */
             /*!
              \property QChart::chartType
              Chart type indicates if the chart is a cartesian chart or a polar chart.
              This property is set internally and it is read only.
              \sa QPolarChart
              */
             /*!
              \property QChart::plotAreaBackgroundVisible
              Specifies whether the chart plot area background is visible or not.
              \note By default the plot area background is not visible and the plot area uses
              the general chart background.
              \sa setPlotAreaBackgroundBrush(), setPlotAreaBackgroundPen(), backgroundVisible
              */
             /*!
              \internal
              Constructs a chart object of \a type which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              This constructor is called only by subclasses.
             */
             QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, type))
             {
                 d_ptr->init();
             }
             /*!
              Constructs a chart object which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, ChartTypeCartesian))
             {
                 d_ptr->init();
             }
             /*!
              Destroys the chart object and its children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of it.
              \note A newly added series is attached to no axes by default, including any axes that were created for the chart
              using createDefaultAxes() before the series was added to the chart. If no axes are attached to
              the newly added series before the chart is shown, the series will get drawn as if it had axes with ranges
              that exactly fit the series to the plot area of the chart. This can be confusing if the same chart also displays other
              series that have properly attached axes, so always make sure you either call createDefaultAxes() after
              a series has been added or explicitly attach axes for the series.
              \sa removeSeries(), removeAllSeries(), createDefaultAxes(), QAbstractSeries::attachAxis()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series from the chart.
              The chart releases its ownership of the specified \a series object.
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes and deletes all series objects that have been added to the chart.
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                     removeSeries(s);
                     delete s;
                 }
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
              Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
              Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart title.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
              Gets the font that is used for drawing the chart title.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for drawing the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for drawing the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
              Zooms in the view by a factor of two.
              */
             void QChart::zoomIn()
             {
                 d_ptr->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              \note This is not supported for polar charts.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 if (d_ptr->m_type == QChart::ChartTypePolar)
                     return;
                 d_ptr->zoomIn(rect);
             }
             /*!
              Zooms out the view by a factor of two.
              */
             void QChart::zoomOut()
             {
                 d_ptr->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a custom \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
              Returns a pointer to the horizontal axis attached to the specified \a series.
              If no \a series is specified, the first horizontal axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns a pointer to the vertical axis attached to the specified \a series.
              If no \a series is specified, the first vertical axis added to the chart is returned.
              \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
              Returns the axes attached to the \a series with \a orientation. If no \a series is provided,
              then all axes added to the chart with the specified orientation are returned.
              \sa addAxis(), createDefaultAxes()
              */
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 if (series) {
                     foreach (QAbstractAxis *axis, series->attachedAxes()){
                         if (orientation.testFlag(axis->orientation()))
                             result << axis;
                     }
                 } else {
                     foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                         if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                             result << axis;
                     }
                 }
                 return result;
             }
             /*!
              Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to
              the chart will be deleted.
              \note This function has to be called after all series have been added to the chart. The axes created by this function
              will NOT get automatically attached to any series added to the chart after this function has been called.
              A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing
              if there are other series with properly attached axes also present.
              \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
              \endtable
              If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created.
              If there are several series of different types added to the chart, then each series gets its own axes pair.
              The axes specific to the series can be later obtained from the chart by providing the series as the parameter for axes() function call.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), axes(), setAxisX(), setAxisY(), QAbstractSeries::attachAxis()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays with the chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             QChart::ChartType QChart::chartType() const
             {
                 return d_ptr->m_type;
             }
             /*!
                 Returns the the rectangle within which the drawing of the chart is done.
                 It does not include the area defined by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
             /*!
                 Sets the \a brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundPen(), plotAreaBackgroundBrush()
              */
             void QChart::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundBrush(brush);
             }
             /*!
                 Returns the brush for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundPen(), setPlotAreaBackgroundBrush()
              */
             QBrush QChart::plotAreaBackgroundBrush() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundBrush();
             }
             /*!
                 Sets the \a pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, setPlotAreaBackgroundBrush(), plotAreaBackgroundPen()
              */
             void QChart::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundPen(pen);
             }
             /*!
                 Returns the pen for the background of the plot area of the chart.
                 \sa plotArea(), plotAreaBackgroundVisible, plotAreaBackgroundBrush(), setPlotAreaBackgroundPen()
              */
             QPen QChart::plotAreaBackgroundPen() const
             {
                 return d_ptr->m_presenter->plotAreaBackgroundPen();
             }
             void QChart::setPlotAreaBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setPlotAreaBackgroundVisible(visible);
             }
             bool QChart::isPlotAreaBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isPlotAreaBackgroundVisible();
             }
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
                 For polar charts, \a dx indicates the angle along angular axis instead of distance.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->scroll(dx,dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
               Returns all series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a bottom-aligned horizontal axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any horizontal axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisY(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisX(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Horizontal, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignBottom);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart and attaches it to the \a series as a left-aligned vertical axis.
               The chart takes ownership of both the \a axis and the \a series.
               Any vertical axes previously attached to the \a series are deleted.
               \sa axisX(), axisY(), setAxisX(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisY(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
               Adds the \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
               \sa removeAxis(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::addAxis(QAbstractAxis *axis, Qt::Alignment alignment)
             {
                 d_ptr->m_dataset->addAxis(axis, alignment);
             }
             /*!
               Removes the \a axis from the chart.
               The chart releases its ownership of the specified \a axis object.
               \sa addAxis(), createDefaultAxes(), QAbstractSeries::detachAxis()
             */
             void QChart::removeAxis(QAbstractAxis *axis)
             {
                 d_ptr->m_dataset->removeAxis(axis);
             }
             /*!
               Returns the value in the \a series domain that corresponds to the \a position relative to chart widget.
             */
             QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToValue(position, series);
             }
             /*!
               Returns the position on the chart widget that corresponds to the \a value in the \a series domain.
             */
             QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToPosition(value, series);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q, QChart::ChartType type):
                 q_ptr(q),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q)),
                 m_type(type)
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             // Hackish solution to the problem of explicitly assigning the default pen/brush/font
             // to a series or axis and having theme override it:
             // Initialize pens, brushes, and fonts to something nobody is likely to ever use,
             // so that default theme initialization will always set these properly.
             QPen &QChartPrivate::defaultPen()
             {
                 static QPen *defaultPen = 0;
                 if (!defaultPen)
                     defaultPen = new QPen(QColor(1, 2, 0), 0.93247536);
                 return *defaultPen;
             }
             QBrush &QChartPrivate::defaultBrush()
             {
                 static QBrush *defaultBrush = 0;
                 if (!defaultBrush)
                     defaultBrush = new QBrush(QColor(1, 2, 0), Qt::Dense7Pattern);
                 return *defaultBrush;
             }
             QFont &QChartPrivate::defaultFont()
             {
                 static QFont *defaultFont = 0;
                 if (!defaultFont) {
                     defaultFont = new QFont();
                     defaultFont->setPointSizeF(8.34563465);
                 }
                 return *defaultFont;
             }
             void QChartPrivate::init()
             {
                 m_legend = new LegendScroller(q_ptr);
                 q_ptr->setTheme(QChart::ChartThemeLight);
                 q_ptr->setLayout(m_presenter->layout());
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qchart/tst_qchart.cpp +1 -1

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages