HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2412:38736d0999b4

Fix axis sizehints when labels are angled...

Miikka Heikkinen -

r2412:38736d0999b4

parent child

Context file:

r2412:38736d0999b4

Collapse all files

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +16 -15

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include "chartlayout_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 offset =-min()-0.5;
                 offset = int(offset * delta)%int(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 + 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 = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();
                 qreal width=0;
                 qreal height=0;
-                  switch (which) {
+                switch (which) {
-                    case Qt::MinimumSize:
+                    case Qt::MinimumSize: {
-                        width = fn.boundingRect("...").width();
+                        QRectF boundingRect = labelBoundingRect(fn, "...");
-                        height = fn.height()+labelPadding();
+                        width = qMax(boundingRect.width(), base.width());
-                        width=qMax(width,base.width());
+                        height = boundingRect.height() + labelPadding();
                         height += base.height();
-                        sh = QSizeF(width,height);
+                        sh = QSizeF(width, height);
                         break;
+                    }
                     case Qt::PreferredSize:{
+                        int labelHeight = 0;
-                        for (int i = 0; i < ticksList.size(); ++i)
+                        foreach (const QString& s, ticksList) {
+                            QRect rect = labelBoundingRect(fn, s);
-                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            labelHeight = qMax(rect.height(), labelHeight);
                             width += rect.width();
                         }
-                        height = fn.height()+labelPadding();
+                        height = labelHeight + labelPadding();
-                        width = qMax(width,base.width());
                         height += base.height();
-                        sh = QSizeF(width,height);
+                        width = qMax(width, base.width());
+                        sh = QSizeF(width, height);
                         break;
                     }
                     default:
                       break;
+                }
-                  return sh;
+                return sh;
             }
             #include "moc_chartbarcategoryaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +21 -18

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include "chartlayout_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 offset = - min() - 0.5;
                 offset = int(offset * delta)%int(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() - 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 = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();
                 qreal width=0;
                 qreal height=0;
-                  switch (which) {
+                switch (which) {
-                    case Qt::MinimumSize:
+                    case Qt::MinimumSize: {
-                        width = fn.boundingRect("...").width() + labelPadding();
+                        QRectF boundingRect = labelBoundingRect(fn, "...");
-                        height = fn.height();
+                        width = boundingRect.width() + labelPadding();
-                        width+=base.width();
+                        width += base.width();
-                        if(base.width()>0) width+=labelPadding();
+                        if (base.width() > 0)
-                        height=qMax(height,base.height());
+                            width += labelPadding();
-                        sh = QSizeF(width,height);
+                        height = qMax(boundingRect.height(), base.height());
+                        sh = QSizeF(width, height);
                         break;
+                    }
                     case Qt::PreferredSize:{
+                        int labelWidth = 0;
-                        for (int i = 0; i < ticksList.size(); ++i)
+                        foreach (const QString& s, ticksList) {
+                            QRect rect = labelBoundingRect(fn, s);
-                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            labelWidth = qMax(rect.width(), labelWidth);
-                            height+=rect.height();
+                            height += rect.height();
-                            width=qMax(rect.width()+labelPadding(),width); //one pixel torelance
                         }
-                        height=qMax(height,base.height());
+                        width = labelWidth + labelPadding() + 1;
-                        width+=base.width();
+                        width += base.width();
-                        if(base.width()>0) width+=labelPadding();
+                        if (base.width() > 0)
-                        sh = QSizeF(width,height);
+                            width += labelPadding();
+                        height = qMax(height, base.height());
+                        sh = QSizeF(width, height);
                         break;
                     }
                     default:
                       break;
                   }
                   return sh;
             }
             #include "moc_chartbarcategoryaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartcategoryaxisx_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item)
                 : HorizontalAxis(axis, item, true),
                   m_axis(axis)
             {
             }
             ChartCategoryAxisX::~ChartCategoryAxisX()
             {
             }
             QVector<qreal> ChartCategoryAxisX::calculateLayout() const
             {
                 int tickCount = m_axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 const QRectF &gridRect = gridGeometry();
                 qreal range  = max() - min();
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.width() / range;
                     for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             int x = (m_axis->startValue(m_axis->categoriesLabels().at(i)) - min()) * scale + gridRect.left();
                             points[i] = x;
                         } else {
                             int x = (m_axis->endValue(m_axis->categoriesLabels().at(i - 1)) - min())  * scale + gridRect.left();
                             points[i] = x;
                         }
                     }
                 }
                 return points;
             }
             void ChartCategoryAxisX::updateGeometry()
             {
                 //TODO: this is not optimal when many categories :( , create only visible lables
                 setLabels(m_axis->categoriesLabels() << "");
                 HorizontalAxis::updateGeometry();
             }
             void ChartCategoryAxisX::handleAxisUpdated()
             {
                 updateGeometry();
                 //TODO :: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
-                case Qt::MinimumSize:
+                case Qt::MinimumSize: {
-                    width = fn.boundingRect("...").width();
+                    QRectF boundingRect = labelBoundingRect(fn, "...");
-                    height = fn.height() + labelPadding();
+                    width = qMax(boundingRect.width(), base.width());
-                    width = qMax(width, base.width());
+                    height = boundingRect.height() + labelPadding();
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
+                }
                 case Qt::PreferredSize: {
+                    int labelHeight = 0;
-                    for (int i = 0; i < ticksList.size(); ++i) {
+                    foreach (const QString& s, ticksList) {
-                        QRectF rect = fn.boundingRect(ticksList.at(i));
+                        QRect rect = labelBoundingRect(fn, s);
+                        labelHeight = qMax(rect.height(), labelHeight);
                         width += rect.width();
-                        height = qMax(rect.height() + labelPadding(), height);
                     }
-                    width = qMax(width, base.width());
+                    height = labelHeight + labelPadding();
                     height += base.height();
+                    width = qMax(width, base.width());
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisy.cpp +11 -9

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

src/axis/chartaxis.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "abstractdomain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_labelsAngle(axis->labelsAngle()),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsSimpleTextItem(item)),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 Q_ASSERT(item);
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 handleVisibleChanged(m_axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents,true);
             }
             void ChartAxis::connectSlots()
             {
                 QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(gridVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleVisibleChanged(bool)),this,SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->childItems().size() == 0){
                     QGraphicsLineItem* arrow = new ArrowItem(this, this);
                     arrow->setPen(m_axis->linePen());
                     m_arrow->addToGroup(arrow);
                 }
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem* item = new QGraphicsLineItem(this);
                         item->setPen(m_axis->gridLinePen());
                         m_grid->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
                     arrow->setPen(m_axis->linePen());
                     QGraphicsLineItem* grid = new QGraphicsLineItem(this);
                     grid->setPen(m_axis->gridLinePen());
                     QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
                     label->setFont(m_axis->labelsFont());
                     label->setPen(m_axis->labelsPen());
                     label->setBrush(m_axis->labelsBrush());
                     label->setRotation(m_labelsAngle);
                     m_arrow->addToGroup(arrow);
                     m_grid->addToGroup(grid);
                     m_labels->addToGroup(label);
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(m_axis->shadesPen());
                         shades->setBrush(m_axis->shadesBrush());
                         m_shades->addToGroup(shades);
                     }
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() ||  qFuzzyCompare(min(),max());
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             qreal ChartAxis::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxis::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QFont ChartAxis::font() const
             {
                 return m_axis->labelsFont();
             }
             QFont ChartAxis::titleFont() const
             {
                 return m_axis->titleFont();
             }
             QString ChartAxis::titleText() const
             {
                 return m_axis->titleText();
             }
             void ChartAxis::axisSelected()
             {
                 emit clicked();
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_axis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_axis->alignment();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             //handlers
             void ChartAxis::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxis::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxis::handleLabelsVisibleChanged(bool visible)
             {
                 m_labels->setVisible(visible);
             }
             void ChartAxis::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::handleTitleVisibleChanged(bool visible)
             {
                 m_title->setVisible(visible);
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::handleLabelsPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                 static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleTitleTextChanged(const QString &title)
             {
                 Q_UNUSED(title)
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::handleTitleFontChanged(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if(!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 }else {
                     m_grid->setVisible(m_axis->isGridLineVisible());
                     m_arrow->setVisible(m_axis->isLineVisible());
                     m_shades->setVisible(m_axis->shadesVisible());
                     m_labels->setVisible(m_axis->labelsVisible());
                     m_title->setVisible(m_axis->isTitleVisible());
                 }
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         //we don't want to call invalidate on layout, since it will change minimum size of component,
                         //which we would like to avoid since it causes nasty flips when scrolling or zooming,
                         //instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             //helpers
             QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1){
                     return labels;
                 }
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
             {
             //    Q_ASSERT(m_max > m_min);
                 //    Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = 0;
                 if (ticks > 1)
                     n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1) {
                     return labels;
                 }
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
+            QRect ChartAxis::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
+            {
+                QRect boundingRect = fn.boundingRect(label);
+                // Take label rotation into account
+                if (m_labelsAngle) {
+                    QTransform transform;
+                    transform.rotate(m_labelsAngle);
+                    boundingRect = transform.mapRect(boundingRect);
+                }
+                return boundingRect;
+            }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  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 CHARTAXIS_H
             #define CHARTAXIS_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class ChartAxis : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 ChartAxis(QAbstractAxis *axis, QGraphicsItem* item = 0, bool intervalAxis = false);
                 ~ChartAxis();
                 QAbstractAxis* axis() const { return m_axis; }
                 void setLabelPadding(int padding);
                 int labelPadding() const { return m_labelPadding;};
                 QFont titleFont() const;
                 QString titleText() const;
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; };
                 Qt::Orientation orientation() const;
                 Qt::Alignment alignment() const;
                 void setGeometry(const QRectF &axis, const QRectF &grid);
                 QRectF axisGeometry() const { return m_axisRect; }
                 QRectF gridGeometry() const { return m_gridRect; }
                 void setLabels(const QStringList &labels);
                 QStringList labels() const { return m_labelsList; }
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 QRectF boundingRect() const{
                     return QRectF();
                 }
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             //helpers
                 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);
             protected:
                 void setGeometry(const QRectF &size) { Q_UNUSED(size);};
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
                 QList<QGraphicsItem *> lineItems() { 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();}
                 QFont font() const;
                 qreal min() const;
                 qreal max() const;
+                QRect labelBoundingRect(const QFontMetrics &fn, const QString &label) const;
             //handlers
             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);
             	void handleShadesBrushChanged(const QBrush &brush);
             	void handleShadesPenChanged(const QPen &pen);
             	void handleArrowPenChanged(const QPen &pen);
             	void handleGridPenChanged(const QPen &pen);
             	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:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateLayout(QVector<qreal> &layout);
                 void axisSelected();
                 void connectSlots();
             private:
                 QAbstractAxis *m_axis;
                 int m_labelsAngle;
                 QRectF m_axisRect;
                 QRectF m_gridRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsSimpleTextItem> m_title;
                 QVector<qreal> m_layoutVector;
                 AxisAnimation *m_animation;
                 int m_labelPadding;
                 QStringList m_labelsList;
                 bool m_intervalAxis;
                 friend class AxisAnimation;
                 friend class ArrowItem;
             };
             class ArrowItem: public QGraphicsLineItem
             {
             public:
                 explicit ArrowItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event) {
                     Q_UNUSED(event)
                     m_axis->axisSelected();
                 }
                 QRectF boundingRect() const {
                     return shape().boundingRect();
                 }
                 QPainterPath shape() const {
                     QPainterPath path = QGraphicsLineItem::shape();
                     QRectF rect = path.boundingRect();
                     path.addRect(rect.adjusted(0, 0, m_axis->orientation() != Qt::Horizontal ? 8 : 0, m_axis->orientation() != Qt::Vertical ? 8 : 0));
                     return path;
                 }
             private:
                 ChartAxis *m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXI_H */

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +14 -11

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdatetimeaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "chartlayout_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() / (tickCount - 1);
                 for (int i = 0; i < tickCount; ++i) {
                     int x = i * deltaX + gridRect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartDateTimeAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
                 qreal width = 0;
                 qreal height = 0;
                 if(ticksList.empty()){
                     return sh;
                 }
                 switch (which) {
                 case Qt::MinimumSize:{
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    QRectF boundingRect = labelBoundingRect(fn, "...");
-                    width = fn.averageCharWidth() * count;
+                    width = qMax(boundingRect.width(), base.width());
-                    height = fn.height() + labelPadding();
+                    height = boundingRect.height() + labelPadding();
-                    width = qMax(width,base.width());
                     height += base.height();
-                    sh = QSizeF(width,height);
+                    sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    int labelHeight = 0;
-                    width=fn.averageCharWidth() * count;
+                    foreach (const QString& s, ticksList) {
-                    height=fn.height()+labelPadding();
+                        QRect rect = labelBoundingRect(fn, s);
-                    width=qMax(width,base.width());
+                        labelHeight = qMax(rect.height(), labelHeight);
-                    height+=base.height();
+                        width += rect.width();
-                    sh = QSizeF(width,height);
+                    height = labelHeight + labelPadding();
+                    height += base.height();
+                    width = qMax(width, base.width());
+                    sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartdatetimeaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +12 -14

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdatetimeaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
             #include "chartlayout_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() / (tickCount - 1);
                 for (int i = 0; i < tickCount; ++i) {
                     int y = i * -deltaY + gridRect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartDateTimeAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
                 qreal width = 0;
                 qreal height = 0;
                 if(ticksList.empty()){
                     return sh;
                 }
-                int labelWidth = 0;
-                foreach(const QString& s, ticksList)
-                    labelWidth=qMax(fn.width(s),labelWidth);
                 switch (which) {
                     case Qt::MinimumSize: {
-                        width = fn.boundingRect("...").width() + labelPadding();
+                        QRectF boundingRect = labelBoundingRect(fn, "...");
+                        width = boundingRect.width() + labelPadding();
                         width += base.width();
-                        height = fn.height();
+                        height = qMax(boundingRect.height(), base.height());
-                        height = qMax(height,base.height());
+                        sh = QSizeF(width, height);
-                        sh = QSizeF(width,height);
                         break;
                     }
                     case Qt::PreferredSize: {
+                        int labelWidth = 0;
+                        foreach (const QString& s, ticksList) {
+                            QRect rect = labelBoundingRect(fn, s);
+                            labelWidth = qMax(rect.width(), labelWidth);
+                            height += rect.height();
+                        }
                         width = labelWidth + labelPadding() + 2; //two pixels of tolerance
                         width += base.width();
-                        height = fn.height() * ticksList.count();
+                        height = qMax(height, base.height());
-                        height = qMax(height,base.height());
+                        sh = QSizeF(width, height);
-                        sh = QSizeF(width,height);
                         break;
                     }
                     default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartdatetimeaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/horizontalaxis.cpp +15 -18

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalaxis_p.h"
             #include "qabstractaxis.h"
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartAxis(axis, item, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = 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 *>(axis.at(0));
                 if (alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
                 else if (alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
                 QFontMetrics fn(font());
                 //title
                 if (!titleText().isNull()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.width();
                     QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                             string.remove(string.length() - 4, 1);
                         title->setText(string);
                     } else {
                         title->setText(titleText);
                     }
                     QPointF center = gridRect.center() - title->boundingRect().center();
                     if (alignment() == Qt::AlignTop) {
                         title->setPos(center.x(), axisRect.top());
                     } else  if (alignment() == Qt::AlignBottom) {
                         title->setPos(center.x(), axisRect.bottom() - title->boundingRect().height());
                     }
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(axis.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
-                    if(intervalAxis()&& i+1!=layout.size()) {
+                    QString text = labelList.at(i);
-                        //wrapping in case of interval axis
+                    QRectF boundingRect = labelBoundingRect(fn, text);
-                        const qreal delta = layout[i+1] - layout[i];
+                    qreal size = axisRect.bottom() - axisRect.top() - labelPadding() - title->boundingRect().height();
-                        QString text = labelList.at(i);
+                    if (boundingRect.height() > size) {
-                        if (fn.boundingRect(text).width() + 1 > delta )
+                        QString label = text + "...";
+                        while (boundingRect.height() >= size && label.length() > 3) {
-                            QString label = text + "...";
-                            while (fn.boundingRect(label).width() >= delta && label.length() > 3)
                             label.remove(label.length() - 4, 1);
-                            labelItem->setText(label);
+                            boundingRect = labelBoundingRect(fn, label);
-                        else {
-                            labelItem->setText(text);
                         }
-                    }else{
+                        labelItem->setText(label);
-                        labelItem->setText(labelList.at(i));
+                    } 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 (alignment() == Qt::AlignTop) {
-                        labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() - labelPadding());
+                        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 (alignment() == Qt::AlignBottom) {
-                        labelItem->setPos(layout[i] - center.x(), axisRect.top() + labelPadding());
+                        labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2) + labelPadding());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
                     //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(layout[i] + delta - center.x(), labelItem->pos().y());
                     }
                     //label overlap detection
                     if(labelItem->pos().x() < width ||
                         labelItem->pos().x() < axisRect.left()  ||
-                        labelItem->pos().x() + rect.width() -1 > axisRect.right()){
+                        labelItem->pos().x() + boundingRect.width() -1 > axisRect.right()){
                         labelItem->setVisible(false);
                     } else {
                         labelItem->setVisible(true);
-                        width=rect.width()+labelItem->pos().x();
+                        width = boundingRect.width() + labelItem->pos().x();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], gridRect.top(), layout[i] - layout[i - 1], gridRect.height());
                     }
                     // 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);
                 QFontMetrics fn(titleFont());
                 QSizeF sh(0,0);
                 if (titleText().isNull() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
                         sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
                         sh = QSizeF(fn.boundingRect(axis()->titleText()).width(), fn.height());
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisx.cpp +14 -11

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "chartlayout_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 + i) * deltaX - leftEdge * deltaX + gridRect.left();
                 return points;
             }
             void ChartLogValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::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(font());
                 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 > 1)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize:{
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    QRectF boundingRect = labelBoundingRect(fn, "...");
-                    width = fn.averageCharWidth() * count;
+                    width = qMax(boundingRect.width(), base.width());
-                    height = fn.height() + labelPadding();
+                    height = boundingRect.height() + labelPadding();
-                    width = qMax(width,base.width());
                     height += base.height();
-                    sh = QSizeF(width,height);
+                    sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    int labelHeight = 0;
-                    width=fn.averageCharWidth() * count;
+                    foreach (const QString& s, ticksList) {
-                    height=fn.height()+labelPadding();
+                        QRect rect = labelBoundingRect(fn, s);
-                    width=qMax(width,base.width());
+                        labelHeight = qMax(rect.height(), labelHeight);
-                    height+=base.height();
+                        width += rect.width();
-                    sh = QSizeF(width,height);
+                    height = labelHeight + labelPadding();
+                    height += base.height();
+                    width = qMax(width, base.width());
+                    sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisy.cpp +12 -15

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "chartlayout_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 + i) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartLogValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::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(font());
                 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 > 1)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
                 qreal width = 0;
                 qreal height = 0;
-                 int labelWidth = 0;
-                foreach(const QString& s, ticksList)
-                    labelWidth=qMax(fn.width(s),labelWidth);
                 switch (which) {
                 case Qt::MinimumSize: {
-                    width = fn.boundingRect("...").width() + labelPadding();
+                    QRectF boundingRect = labelBoundingRect(fn, "...");
+                    width = boundingRect.width() + labelPadding();
                     width += base.width();
-                    height = fn.height();
+                    height = qMax(boundingRect.height(), base.height());
-                    height = qMax(height,base.height());
+                    sh = QSizeF(width, height);
-                    sh = QSizeF(width,height);
                     break;
                 }
                 case Qt::PreferredSize: {
+                    int labelWidth = 0;
+                    foreach (const QString& s, ticksList) {
+                        QRect rect = labelBoundingRect(fn, s);
+                        labelWidth = qMax(rect.width(), labelWidth);
+                        height += rect.height();
+                    }
                     width = labelWidth + labelPadding() + 2; //two pixels of tolerance
                     width += base.width();
-                    height = fn.height() * ticksList.count();
+                    height = qMax(height, base.height());
-                    height = qMax(height,base.height());
+                    sh = QSizeF(width, height);
-                    sh = QSizeF(width,height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx.cpp +14 -18

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartvalueaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "chartlayout_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() / (tickCount - 1);
                 for (int i = 0; i < tickCount; ++i) {
                     points[i] = i * deltaX + gridRect.left();
                 }
                 return points;
             }
             void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                     case Qt::MinimumSize: {
-                        if(!ticksList.empty()) {
+                        QRectF boundingRect = labelBoundingRect(fn, "...");
-                            foreach(QString label,ticksList) {
+                        width = qMax(boundingRect.width(), base.width());
-                                width = qMax(qreal(fn.boundingRect(label).width()),width);
+                        height = boundingRect.height() + labelPadding();
-                        height = fn.height() + labelPadding();
-                        width = qMax(width,base.width());
                         height += base.height();
-                        sh = QSizeF(width,height);
+                        sh = QSizeF(width, height);
                         break;
                     }
                     case Qt::PreferredSize: {
-                        if(!ticksList.empty()) {
+                        int labelHeight = 0;
-                            foreach(QString label,ticksList) {
+                        foreach (const QString& s, ticksList) {
-                                width+=fn.boundingRect(label).width();
+                            QRect rect = labelBoundingRect(fn, s);
+                            labelHeight = qMax(rect.height(), labelHeight);
+                            width += rect.width();
                         }
-                        height=fn.height()+labelPadding();
+                        height = labelHeight + labelPadding();
-                        width=qMax(width,base.width());
+                        height += base.height();
-                        height+=base.height();
+                        width = qMax(width, base.width());
-                        sh = QSizeF(width,height);
+                        sh = QSizeF(width, height);
                         break;
                     }
                     default:
-                    break;
+                        break;
                 }
                 return sh;
             }
             #include "moc_chartvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy.cpp +13 -16

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartvalueaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
             #include "chartlayout_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() / (tickCount - 1);
                 for (int i = 0; i < tickCount; ++i) {
                     points[i] = i * -deltaY + gridRect.bottom();
                 }
                 return points;
             }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::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(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 qreal height = 0;
-                int labelWidth = 0;
-                foreach(const QString& s, ticksList)
-                    labelWidth=qMax(fn.width(s),labelWidth);
                 switch (which) {
                 case Qt::MinimumSize: {
-                    width = fn.boundingRect("...").width() + labelPadding();
+                    QRectF boundingRect = labelBoundingRect(fn, "...");
+                    width = boundingRect.width() + labelPadding();
                     width += base.width();
-                    height = fn.height();
+                    height = qMax(boundingRect.height(), base.height());
-                    height = qMax(height,base.height());
+                    sh = QSizeF(width, height);
-                    sh = QSizeF(width,height);
                     break;
                 }
-                case Qt::PreferredSize:
+                case Qt::PreferredSize: {
+                    int labelWidth = 0;
+                    foreach (const QString& s, ticksList) {
+                        QRect rect = labelBoundingRect(fn, s);
+                        labelWidth = qMax(rect.width(), labelWidth);
+                        height += rect.height();
+                    }
                     width = labelWidth + labelPadding() + 2; //two pixels of tolerance
                     width += base.width();
-                    height = fn.height() * ticksList.count();
+                    height = qMax(height, base.height());
-                    height = qMax(height,base.height());
+                    sh = QSizeF(width, height);
-                    sh = QSizeF(width,height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/verticalaxis.cpp +13 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "verticalaxis_p.h"
             #include "qabstractaxis.h"
             #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem* item, bool intervalAxis)
                 : ChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = 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*>(axis.at(0));
                 //arrow position
                 if (alignment()==Qt::AlignLeft)
                     arrowItem->setLine( axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if(alignment()==Qt::AlignRight)
                     arrowItem->setLine( axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
                 QFontMetrics fn(font());
                 //title
                 if (!titleText().isNull()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.height();
                     QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                         title->setText(string);
                     }
                     else {
                         title->setText(titleText);
                     }
                     QPointF center = gridRect.center() - title->boundingRect().center();
                     if (alignment() == Qt::AlignLeft) {
                         title->setPos(axisRect.left() - title->boundingRect().width()/2 + title->boundingRect().height()/2 , center.y());
                     }
                     else if (alignment() == Qt::AlignRight) {
                         title->setPos(axisRect.right()- title->boundingRect().width()/2 - title->boundingRect().height()/2, center.y());
                     }
                     title->setTransformOriginPoint(title->boundingRect().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 *>(axis.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);
                     qreal size = axisRect.right() - axisRect.left() - labelPadding() - title->boundingRect().height();
-                    if (fn.boundingRect(text).width() > size) {
+                    if (boundingRect.width() > size) {
                         QString label = text + "...";
-                        while (fn.boundingRect(label).width() > size && label.length() > 3)
+                        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 (alignment() == Qt::AlignLeft) {
-                        labelItem->setPos(axisRect.right() - rect.width() - labelPadding() , layout[i] - center.y());
+                        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 (alignment() == Qt::AlignRight) {
-                        labelItem->setPos(axisRect.left() + labelPadding() , layout[i] - center.y());
+                        labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2), layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(labelItem->pos().x() , layout[i] + delta - center.y());
                     }
                     //label overlap detection
-                    if(labelItem->pos().y() + rect.height() > height ||
+                    if(labelItem->pos().y() + boundingRect.height() > height ||
-                        labelItem->pos().y() + rect.height()/2 > gridRect.bottom() ||
+                        labelItem->pos().y() + boundingRect.height()/2 > gridRect.bottom() ||
-                        labelItem->pos().y() + rect.height()/2 < gridRect.top()) {
+                        labelItem->pos().y() + boundingRect.height()/2 < gridRect.top()) {
                         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));
                         rectItem->setRect(gridRect.left(), layout[i], gridRect.width(), layout[i - 1] - layout[i]);
                     }
                     // 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);
                 QFontMetrics fn(titleFont());
                 QSizeF sh(0,0);
                 if (titleText().isNull() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
                         sh = QSizeF(fn.height(), fn.boundingRect("...").width());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
                         sh = QSizeF(fn.height(), fn.boundingRect(axis()->titleText()).width());
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             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