HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2534:ec1756baf233

Fix multiline axis label positioning....

Miikka Heikkinen -

r2534:ec1756baf233

parent child

Context file:

r2534:ec1756baf233

Collapse all files

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +5 -9

             /****************************************************************************
              **
              ** 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 <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                        height = boundingRect.height() + labelPadding();
+                        height = boundingRect.height() + labelPadding() + base.height() + 1.0;
-                        height += base.height();
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize:{
-                        int labelHeight = 0;
+                        qreal labelHeight = 0.0;
                         foreach (const QString& s, ticksList) {
-                            QRect rect = labelBoundingRect(fn, s);
+                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelHeight = qMax(rect.height(), labelHeight);
                         }
-                        height = labelHeight + labelPadding();
+                        height = labelHeight + labelPadding() + base.height() + 1.0;
-                        height += base.height();
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                       break;
                 }
                 return sh;
             }
             #include "moc_chartbarcategoryaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +7 -11

             /****************************************************************************
              **
              ** 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 <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                        width = boundingRect.width() + labelPadding();
+                        width = boundingRect.width() + labelPadding() + base.width() + 1.0;
-                        width += base.width();
+                        if (base.width() > 0.0)
-                        if (base.width() > 0)
                             width += labelPadding();
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize:{
-                        int labelWidth = 0;
+                        qreal labelWidth = 0.0;
                         foreach (const QString& s, ticksList) {
-                            QRect rect = labelBoundingRect(fn, s);
+                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelWidth = qMax(rect.width(), labelWidth);
                         }
-                        width = labelWidth + labelPadding() + 1;
+                        width = labelWidth + labelPadding() + base.width() + 1.0;
-                        width += base.width();
+                        if (base.width() > 0.0)
-                        if (base.width() > 0)
                             width += labelPadding();
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                       break;
                   }
                   return sh;
             }
             #include "moc_chartbarcategoryaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisx.cpp +5 -9

             /****************************************************************************
             **
             ** 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 <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                    height = boundingRect.height() + labelPadding();
+                    height = boundingRect.height() + labelPadding() + base.height() + 1.0;
-                    height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelHeight = 0;
+                    qreal labelHeight = 0.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                     }
-                    height = labelHeight + labelPadding();
+                    height = labelHeight + labelPadding() + base.height() + 1.0;
-                    height += base.height();
                     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 +5 -9

             /****************************************************************************
             **
             ** 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 <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                    width = boundingRect.width() + labelPadding();
+                    width = boundingRect.width() + labelPadding() + base.width() + 1.0;
-                    width += base.width();
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelWidth = 0;
+                    qreal labelWidth = 0.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                     }
-                    width = labelWidth + labelPadding() + 1;
+                    width = labelWidth + labelPadding() + base.width() + 1.0;
-                    width += base.width();
                     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 +41 -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 "chartaxiselement_p.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QDateTime>
-            #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            QGraphicsSimpleTextItem *dummyTextItem = 0;
+            class StaticDeleter
+            {
+            public:
+                StaticDeleter() {}
+                ~StaticDeleter() { delete dummyTextItem; }
+            };
+            StaticDeleter staticDeleter;
             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_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())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setText(title);
             }
             void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             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();
             }
-            QRect ChartAxisElement::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
+            QRectF ChartAxisElement::textBoundingRect(const QFont &font, const QString &text, qreal angle) const
             {
-                QRect boundingRect = fn.boundingRect(label);
+                dummyTextItem->setFont(font);
-                // Take label rotation into account
+                dummyTextItem->setText(text);
-                if (axis()->labelsAngle()) {
+                QRectF boundingRect = dummyTextItem->boundingRect();
+                // Take rotation into account
+                if (angle) {
                     QTransform transform;
-                    transform.rotate(axis()->labelsAngle());
+                    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();
             }
             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();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                             || format.contains("i")
                             || format.contains("c")) {
                             labels << QString().sprintf(array, (qint64)value);
                         } else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive)) {
                             labels << QString().sprintf(array, (quint64)value);
                         } else if (format.contains("f", Qt::CaseInsensitive)
                                  || format.contains("e", Qt::CaseInsensitive)
                                  || format.contains("g", Qt::CaseInsensitive)) {
                             labels << QString().sprintf(array, value);
                         } else {
                             labels << QString();
                         }
                     }
                 }
                 return labels;
             }
             QStringList 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();
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         if (format.contains("d")
                             || format.contains("i")
                             || format.contains("c")) {
                             labels << QString().sprintf(array, (qint64)value);
                         } else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive)) {
                             labels << QString().sprintf(array, (quint64)value);
                         } else if (format.contains("f", Qt::CaseInsensitive)
                                  || format.contains("e", Qt::CaseInsensitive)
                                  || format.contains("g", Qt::CaseInsensitive)) {
                             labels << QString().sprintf(array, value);
                         } else {
                             labels << QString();
                         }
                     }
                 }
                 return labels;
             }
             QStringList 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 +3 -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 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; }
-                QRect labelBoundingRect(const QFontMetrics &fn, const QString &label) const;
+                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(); }
                 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;
                 bool m_intervalAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXISELEMENT_H */

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +8 -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 "chartdatetimeaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QDateTime>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() / 2.0;
-                    height = boundingRect.height() + labelPadding();
+                    height = boundingRect.height() + labelPadding() + base.height() + 1.0;
-                    height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelHeight = 0;
+                    qreal labelHeight = 0.0;
-                    int firstWidth = -1;
+                    qreal firstWidth = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                         width = rect.width();
-                        if (firstWidth < 0)
+                        if (firstWidth < 0.0)
                             firstWidth = width;
                     }
-                    height = labelHeight + labelPadding();
+                    height = labelHeight + labelPadding() + base.height() + 1.0;
-                    height += base.height();
+                    width = qMax(width, firstWidth) / 2.0;
-                    width = qMax(width, qreal(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 +8 -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 "chartdatetimeaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                        width = boundingRect.width() + labelPadding();
+                        width = boundingRect.width() + labelPadding() + base.width() + 1.0;
-                        width += base.width();
                         height = boundingRect.height() / 2.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize: {
-                        int labelWidth = 0;
+                        qreal labelWidth = 0.0;
-                        int firstHeight = -1;
+                        qreal firstHeight = -1.0;
                         foreach (const QString& s, ticksList) {
-                            QRect rect = labelBoundingRect(fn, s);
+                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelWidth = qMax(rect.width(), labelWidth);
                             height = rect.height();
-                            if (firstHeight < 0)
+                            if (firstHeight < 0.0)
                                 firstHeight = height;
                         }
-                        width = labelWidth + labelPadding() + 2; //two pixels of tolerance
+                        width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
-                        width += base.width();
+                        height = qMax(height, firstHeight) / 2.0;
-                        height = qMax(height, qreal(firstHeight)) / 2.0;
                         sh = QSizeF(width, height);
                         break;
                     }
                     default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartdatetimeaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/horizontalaxis.cpp +7 -39

             /****************************************************************************
             **
             ** 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 <QFontMetrics>
             #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();
                 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;
-                QFontMetrics fn(axis()->labelsFont());
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
-                    int size(0);
+                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, gridRect.width(), Qt::Horizontal, QRectF()));
-                    size = gridRect.width();
-                    QGraphicsSimpleTextItem dummyTitle;
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(axis()->titleText());
-                    QRectF dummyRect = dummyTitle.boundingRect();
-                    if (dummyRect.width() > size) {
-                        QString string = titleText + "...";
-                        while (dummyRect.width() > size && string.length() > 3) {
-                            string.remove(string.length() - 4, 1);
-                            dummyTitle.setText(string);
-                            dummyRect = dummyTitle.boundingRect();
-                        title->setText(string);
-                    } else {
-                        title->setText(titleText);
                     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));
                     //grid line
                     gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
                     //label text wrapping
                     QString text = labelList.at(i);
-                    QRectF boundingRect = labelBoundingRect(fn, text);
+                    QRectF boundingRect;
                     qreal size = axisRect.bottom() - axisRect.top() - labelPadding() - titleBoundingRect.height() - (titlePad * 2);
-                    if (boundingRect.height() > size) {
+                    labelItem->setText(truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
-                        QString label = text + "...";
+                                                     size, Qt::Vertical, boundingRect));
-                        while (boundingRect.height() >= size && label.length() > 3) {
-                            label.remove(label.length() - 4, 1);
-                            boundingRect = labelBoundingRect(fn, label);
-                        labelItem->setText(label);
-                    } else {
-                        labelItem->setText(text);
                     //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: {
-                    QFontMetrics fn(axis()->titleFont());
+                    QRectF titleRect = textBoundingRect(axis()->titleFont(), "...");
-                    sh = QSizeF(fn.boundingRect("...").width(), fn.height() + (titlePadding() * 2));
+                    sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2));
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
-                    QGraphicsSimpleTextItem dummyTitle;
+                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(axis()->titleText());
-                    QRectF titleRect = dummyTitle.boundingRect();
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2));
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisx.cpp +8 -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 "chartlogvalueaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                     width = boundingRect.width() / 2.0;
-                    height = boundingRect.height() + labelPadding();
+                    height = boundingRect.height() + labelPadding() + base.height() + 1.0;
-                    height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelHeight = 0;
+                    qreal labelHeight = 0.0;
-                    int firstWidth = -1;
+                    qreal firstWidth = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelHeight = qMax(rect.height(), labelHeight);
                         width = rect.width();
-                        if (firstWidth < 0)
+                        if (firstWidth < 0.0)
                             firstWidth = width;
                     }
-                    height = labelHeight + labelPadding();
+                    height = labelHeight + labelPadding() + base.height() + 1.0;
-                    height += base.height();
+                    width = qMax(width, firstWidth) / 2.0;
-                    width = qMax(width, qreal(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 +8 -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 "chartlogvalueaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                    width = boundingRect.width() + labelPadding();
+                    width = boundingRect.width() + labelPadding() + base.width() + 1.0;
-                    width += base.width();
                     height = boundingRect.height() / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelWidth = 0;
+                    qreal labelWidth = 0.0;
-                    int firstHeight = -1;
+                    qreal firstHeight = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                         height = rect.height();
-                        if (firstHeight < 0)
+                        if (firstHeight < 0.0)
                             firstHeight = height;
                     }
-                    width = labelWidth + labelPadding() + 2; //two pixels of tolerance
+                    width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
-                    width += base.width();
+                    height = qMax(height, firstHeight) / 2.0;
-                    height = qMax(height, qreal(firstHeight)) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisangular.cpp +6 -31

             /****************************************************************************
             **
             ** 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 <QFontMetrics>
             #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();
                 QGraphicsEllipseItem *axisLine = static_cast<QGraphicsEllipseItem *>(arrowItemList.at(0));
                 axisLine->setRect(axisGeometry());
                 qreal radius = axisGeometry().height() / 2.0;
-                QFontMetrics fn(axis()->labelsFont());
                 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));
                     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));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
-                        QRectF boundingRect = labelBoundingRect(fn, labelList.at(i));
+                        QRectF boundingRect = 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()) {
-                    int size(0);
+                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, axisGeometry().width(), Qt::Horizontal, QRectF()));
-                    size = axisGeometry().width();
-                    QGraphicsSimpleTextItem dummyTitle;
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(titleText);
-                    QRectF dummyRect = dummyTitle.boundingRect();
-                    if (dummyRect.width() > size) {
-                        QString string = titleText + "...";
-                        while (dummyRect.width() > size && string.length() > 3) {
-                            string.remove(string.length() - 4, 1);
-                            dummyTitle.setText(string);
-                            dummyRect = dummyTitle.boundingRect();
-                        title->setText(string);
-                    } else {
-                        title->setText(titleText);
-                    QRectF titleBoundingRect;
+                    QRectF titleBoundingRect = title->boundingRect();
-                    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());
                     QGraphicsSimpleTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setPen(axis()->labelsPen());
                     label->setBrush(axis()->labelsBrush());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
                     title->setPen(axis()->titlePen());
                     title->setBrush(axis()->titleBrush());
                     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.
-                    QFontMetrics fm(font);
                     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 = labelBoundingRect(fm, labelList.at(i));
+                        QRectF boundingRect = 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()) {
-                    QGraphicsSimpleTextItem dummyTitle;
+                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(axis()->titleText());
-                    QRectF dummyRect = dummyTitle.boundingRect();
-                    radius -= titlePadding() + (dummyRect.height() / 2.0);
+                    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 +3 -21

             /****************************************************************************
             **
             ** 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"
-            #include <QFontMetrics>
             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();
                 qreal radius = axisGeometry().height() / 2.0;
                 QLineF line(center, center + QPointF(0, -radius));
                 QGraphicsLineItem *axisLine = static_cast<QGraphicsLineItem *>(arrowItemList.at(0));
                 axisLine->setLine(line);
-                QFontMetrics fn(axis()->labelsFont());
                 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));
                     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));
                         QRectF labelRect = labelItem->boundingRect();
                         QPointF labelCenter = labelRect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
-                        QRectF boundingRect = labelBoundingRect(fn, labelList.at(i));
+                        QRectF boundingRect = 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()) {
-                    QGraphicsSimpleTextItem dummyTitle;
+                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, radius, Qt::Horizontal, QRectF()));
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(titleText);
-                    QRectF dummyRect = dummyTitle.boundingRect();
-                    if (dummyRect.width() > radius) {
-                        QString string = titleText + "...";
-                        while (dummyRect.width() > radius && string.length() > 3) {
-                            string.remove(string.length() - 4, 1);
-                            dummyTitle.setText(string);
-                            dummyRect = dummyTitle.boundingRect();
-                        title->setText(string);
-                    } else {
-                        title->setText(titleText);
-                    QRectF titleBoundingRect;
+                    QRectF titleBoundingRect = title->boundingRect();
-                    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());
                     QGraphicsSimpleTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setPen(axis()->labelsPen());
                     label->setBrush(axis()->labelsBrush());
                     label->setRotation(axis()->labelsAngle());
                     title->setFont(axis()->titleFont());
                     title->setPen(axis()->titlePen());
                     title->setBrush(axis()->titleBrush());
                     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/valueaxis/chartvalueaxisx.cpp +8 -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 "chartvalueaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                        QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
                         width = boundingRect.width() / 2.0;
-                        height = boundingRect.height() + labelPadding();
+                        height = boundingRect.height() + labelPadding() + base.height() + 1.0;
-                        height += base.height();
                         sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize: {
-                        int labelHeight = 0;
+                        qreal labelHeight = 0.0;
-                        int firstWidth = -1;
+                        qreal firstWidth = -1.0;
                         foreach (const QString& s, ticksList) {
-                            QRect rect = labelBoundingRect(fn, s);
+                            QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                             labelHeight = qMax(rect.height(), labelHeight);
                             width = rect.width();
-                            if (firstWidth < 0)
+                            if (firstWidth < 0.0)
                                 firstWidth = width;
                         }
-                        height = labelHeight + labelPadding();
+                        height = labelHeight + labelPadding() + base.height() + 1.0;
-                        height += base.height();
+                        width = qMax(width, firstWidth) / 2.0;
-                        width = qMax(width, qreal(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 +8 -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 "chartvalueaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
-            #include <QFontMetrics>
             #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)
-                QFontMetrics fn(axis()->labelsFont());
                 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 = labelBoundingRect(fn, "...");
+                    QRectF boundingRect = textBoundingRect(axis()->labelsFont(), "...", axis()->labelsAngle());
-                    width = boundingRect.width() + labelPadding();
+                    width = boundingRect.width() + labelPadding() + base.width() + 1.0;
-                    width += base.width();
                     height = boundingRect.height() / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int labelWidth = 0;
+                    qreal labelWidth = 0.0;
-                    int firstHeight = -1;
+                    qreal firstHeight = -1.0;
                     foreach (const QString& s, ticksList) {
-                        QRect rect = labelBoundingRect(fn, s);
+                        QRectF rect = textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                         height = rect.height();
-                        if (firstHeight < 0)
+                        if (firstHeight < 0.0)
                             firstHeight = height;
                     }
-                    width = labelWidth + labelPadding() + 2; //two pixels of tolerance
+                    width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
-                    width += base.width();
+                    height = qMax(height, firstHeight) / 2.0;
-                    height = qMax(height, qreal(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 -41

             /****************************************************************************
             **
             ** 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 <QFontMetrics>
             #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();
                 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());
-                QFontMetrics fn(axis()->labelsFont());
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
-                    int size(0);
+                    title->setText(truncatedText(axis()->titleFont(), titleText, 0.0, gridRect.height(), Qt::Horizontal, QRectF()));
-                    size = gridRect.height();
-                    QGraphicsSimpleTextItem dummyTitle;
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(axis()->titleText());
-                    QRectF dummyRect = dummyTitle.boundingRect();
-                    if (dummyRect.width() > size) {
-                        QString string = titleText + "...";
-                        while (dummyRect.width() > size && string.length() > 3) {
-                            string.remove(string.length() - 4, 1);
-                            dummyTitle.setText(string);
-                            dummyRect = dummyTitle.boundingRect();
-                        title->setText(string);
-                    } else {
-                        title->setText(titleText);
                     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));
                     //grid line
                     gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
                     //label text wrapping
                     QString text = labelList.at(i);
-                    QRectF boundingRect = labelBoundingRect(fn, text);
+                    QRectF boundingRect;
                     qreal size = axisRect.right() - axisRect.left() - labelPadding() - titleBoundingRect.height() - (titlePad * 2);
-                    if (boundingRect.width() > size) {
+                    labelItem->setText(truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
-                        QString label = text + "...";
+                                                     size, Qt::Horizontal, boundingRect));
-                        while (boundingRect.width() > size && label.length() > 3) {
-                            label.remove(label.length() - 4, 1);
-                            boundingRect = labelBoundingRect(fn, label);
-                        labelItem->setText(label);
-                    } else {
-                        labelItem->setText(text);
                     //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: {
-                    QFontMetrics fn(axis()->titleFont());
+                    QRectF titleRect = textBoundingRect(axis()->titleFont(), "...");
-                    sh = QSizeF(fn.height() + (titlePadding() * 2), fn.boundingRect("...").width());
+                    sh = QSizeF(titleRect.height() + (titlePadding() * 2), titleRect.width());
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
-                    QGraphicsSimpleTextItem dummyTitle;
+                    QRectF titleRect = textBoundingRect(axis()->titleFont(), axis()->titleText());
-                    dummyTitle.setFont(axis()->titleFont());
-                    dummyTitle.setText(axis()->titleText());
-                    QRectF titleRect = dummyTitle.boundingRect();
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2), titleRect.width());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/layout/polarchartlayout.cpp +1 -5

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartlayout_p.h"
             #include "chartpresenter_p.h"
             #include "polarchartaxis_p.h"
             #include <QDebug>
-            #include <QFontMetrics>
             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
-                        QGraphicsSimpleTextItem dummyTitle;
+                        QRectF dummyRect = chartAxis->textBoundingRect(chartAxis->axis()->titleFont(), chartAxis->axis()->titleText());
-                        dummyTitle.setFont(chartAxis->axis()->titleFont());
-                        dummyTitle.setText(chartAxis->axis()->titleText());
-                        QRectF dummyRect = dummyTitle.boundingRect();
                         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

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