HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2133:8c175959daec

Updates axis drawing code...

Michal Klocek -

r2133:8c175959daec

parent child

Context file:

r2133:8c175959daec

Collapse all files

demos/chartviewer/charts/axis/barcategoryaxisx.cpp +4 -2

             /****************************************************************************
             **
             ** 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 "charts.h"
             #include "qchart.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             class BarCategoryAxisX: public Chart
             {
             public:
                 QString name() { return "AxisX"; }
                 QString category()  { return QObject::tr("Axis"); }
                 QString subCategory() { return "BarCategoryAxis"; }
                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = new QChart();
                     chart->setTitle(" BarCateogry X , Value Y");
                     QString name("Series ");
                     QBarSeries *series = new QBarSeries(chart);
                     QValueAxis *valueaxis = new QValueAxis();
                     QBarCategoryAxis *barcategory = new QBarCategoryAxis();
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach (Data data, table[i])
                             *set << data.first.y();
                         series->append(set);
                     }
                     chart->addSeries(series);
                     int count = series->barSets().first()->count();
-                    for (int i = 0; i < count; i++)
-                        barcategory->append(QString::number(i));
+                    for (int i = 0; i < count; i++) {
+                        barcategory->append("BarSet " + QString::number(i));
+                    }
                     chart->setAxisY(valueaxis, series);
                     chart->setAxisX(barcategory, series);
                     return chart;
                 }
             };
             DECLARE_CHART(BarCategoryAxisX);

demos/chartviewer/charts/axis/barcategoryaxisy.cpp +3 -2

             /****************************************************************************
             **
             ** 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 "charts.h"
             #include "qchart.h"
             #include "qhorizontalbarseries.h"
             #include "qbarset.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             class BarCategoryAxisY: public Chart
             {
             public:
                 QString name() { return "AxisY"; }
                 QString category()  { return QObject::tr("Axis"); }
                 QString subCategory() { return "BarCategoryAxis"; }
                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = new QChart();
                     chart->setTitle(" BarCateogry Y , Value X");
                     QString name("Series ");
                     QHorizontalBarSeries *series = new QHorizontalBarSeries(chart);
                     QValueAxis *valueaxis = new QValueAxis();
                     QBarCategoryAxis *barcategory = new QBarCategoryAxis();
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                         foreach(Data data, table[i])
                             *set << data.first.y();
                         series->append(set);
                     }
                     chart->addSeries(series);
                     int count = series->barSets().first()->count();
-                    for (int i = 0; i < count; i++)
+                    for (int i = 0; i < count; i++) {
-                        barcategory->append(QString::number(i));
+                        barcategory->append("BarSet " + QString::number(i));
+                    }
                     chart->setAxisX(valueaxis, series);
                     chart->setAxisY(barcategory, series);
                     return chart;
                 }
             };
             DECLARE_CHART(BarCategoryAxisY);

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +43 -42

             /****************************************************************************
              **
              ** 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 <QFontMetrics>
             #include <QDebug>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter)
                 : HorizontalAxis(axis, presenter, true),
                   m_categoriesAxis(axis)
             {
             }
             ChartBarCategoryAxisX::~ChartBarCategoryAxisX()
             {
             }
             QVector<qreal> ChartBarCategoryAxisX::calculateLayout() const
             {
-                int count = m_categoriesAxis->d_ptr->count();
+                QVector<qreal> points;
-                Q_ASSERT(count >= 1);
+                const QRectF& gridRect = gridGeometry();
+                qreal range = max() - min();
-                QVector<qreal> points;
+                const qreal delta = gridRect.width()/range;
-                points.resize(count + 2);
-                const QRectF &gridRect = gridGeometry();
+                if(delta<2) return points;
+                qreal offset =-min()-0.5;
+                offset = int(offset * delta)%int(delta);
-                const qreal delta = gridRect.width() / (count);
+                int count = qFloor(range);
-                qreal offset = -min() - 0.5;
-                if (delta < 1)
+                if(count < 1 ) return points;
-                    return points;
-                if (offset < 0)
+                points.resize(count+2);
-                    offset = int(offset * gridRect.width() / (max() - min())) % int(delta) + delta;
-                else
-                    offset = int(offset * gridRect.width() / (max() - min())) % int(delta);
-                for (int i = -1; i < count + 1; ++i) {
+                for (int i = 0; i < count+2; ++i) {
                     qreal x = offset + i * delta + gridRect.left();
-                    points[i + 1] = x;
+                    points[i] = x;
                 }
                 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::handleAxisUpdated()
             {
                 if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
                     if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
                         updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createCategoryLabels(ChartAxis::layout());
-                qreal width = 0;
-                qreal height = 0;
-                switch (which) {
-                case Qt::MinimumSize:
-                    width = fn.boundingRect("...").width();
-                    height = fn.height() + labelPadding();
-                    width = qMax(width, base.width());
-                    height += base.height();
-                    sh = QSizeF(width, height);
-                    break;
-                case Qt::PreferredSize: {
-                    for (int i = 0; i < ticksList.size(); ++i) {
-                        QRectF rect = fn.boundingRect(ticksList.at(i));
-                        width += rect.width();
-                        height = qMax(rect.height() + labelPadding(), height);
-                    width = qMax(width, base.width());
-                    height += base.height();
-                    sh = QSizeF(width, height);
-                    break;
-                default:
-                    break;
-                return sh;
+                qreal width=0;
+                qreal height=0;
+                  switch (which) {
+                    case Qt::MinimumSize:
+                        width = fn.boundingRect("...").width();
+                        height = fn.height()+labelPadding();
+                        width=qMax(width,base.width());
+                        height += base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    case Qt::PreferredSize:{
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            width += rect.width();
+                        }
+                        height = fn.height()+labelPadding();
+                        width = qMax(width,base.width());
+                        height += base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +29 -27

             /****************************************************************************
              **
              ** 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 <qmath.h>
             #include <QFontMetrics>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter)
                 : VerticalAxis(axis, presenter, true),
                   m_categoriesAxis(axis)
             {
             }
             ChartBarCategoryAxisY::~ChartBarCategoryAxisY()
             {
             }
             QVector<qreal> ChartBarCategoryAxisY::calculateLayout() const
             {
                 int count = m_categoriesAxis->d_ptr->count();
                 Q_ASSERT(count >= 1);
                 QVector<qreal> points;
                 points.resize(count + 2);
                 const QRectF &gridRect = gridGeometry();
                 const qreal delta = gridRect.height() / (count);
                 qreal offset = - min() - 0.5;
                 if (delta < 1)
                     return points;
                 if (offset < 0)
                     offset = int(offset * gridRect.height() / (max() - min())) % int(delta) + delta;
                 else
                     offset = int(offset * gridRect.height() / (max() - min())) % int(delta);
                 for (int i = -1; i < count + 1; ++i) {
                     int y = gridRect.bottom() - i * delta - offset;
                     points[i + 1] = y;
                 }
                 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::handleAxisUpdated()
             {
                 if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
                     if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
                         updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createCategoryLabels(ChartAxis::layout());
-                qreal width = 0;
-                qreal height = 0;
-                switch (which) {
-                case Qt::MinimumSize:
-                    width = fn.boundingRect("...").width() + labelPadding();
-                    height = fn.height();
-                    width += base.width();
-                    height = qMax(height, base.height());
-                    sh = QSizeF(width, height);
-                    break;
-                case Qt::PreferredSize: {
-                    for (int i = 0; i < ticksList.size(); ++i) {
-                        QRectF rect = fn.boundingRect(ticksList.at(i));
-                        height += rect.height();
-                        width = qMax(rect.width() + labelPadding(), width);
-                    height = qMax(height, base.height());
-                    width += base.width();
-                    sh = QSizeF(width, height);
-                    break;
-                default:
-                    break;
-                return sh;
+                qreal width=0;
+                qreal height=0;
+                  switch (which) {
+                    case Qt::MinimumSize:
+                        width = fn.boundingRect("...").width() + labelPadding();
+                        height = fn.height();
+                        width+=base.width();
+                        height=qMax(height,base.height());
+                        sh = QSizeF(width,height);
+                        break;
+                    case Qt::PreferredSize:{
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            height+=rect.height();
+                            width=qMax(rect.width()+labelPadding() +1 ,width); //one pixel torelance
+                        }
+                        height=qMax(height,base.height());
+                        width+=base.width();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis.cpp +2 -3

             /****************************************************************************
             **
             ** 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 "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartElement(presenter),
                   m_chartAxis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                   m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                   m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                   m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                   m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
                   m_min(0),
                   m_max(0),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(), SIGNAL(updated()), this, SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             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->children().size() == 0)
                     m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
                 if (m_intervalAxis && m_grid->children().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++)
                         m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                 }
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     m_labels->addToGroup(new QGraphicsSimpleTextItem(presenter()->rootItem()));
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
                         m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
             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 (diff < 0) handleAxisUpdated();
                 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::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 if (m_font != font) {
                     m_font = font;
                     foreach (QGraphicsItem *item , m_labels->childItems())
                         static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return !m_axisRect.isValid() || m_gridRect.isEmpty() || qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain *domain = qobject_cast<Domain *>(sender());
                 qreal min(0);
                 qreal max(0);
                 if (m_chartAxis->orientation() == Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 } else if (m_chartAxis->orientation() == Qt::Vertical) {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
-                        QSizeF before = effectiveSizeHint(Qt::MinimumSize);
+                        QSizeF before = effectiveSizeHint(Qt::PreferredSize);
+                        QSizeF after = sizeHint(Qt::PreferredSize);
-                        QSizeF after = sizeHint(Qt::MinimumSize);
                         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());
                         }
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty())
                     return;
                 bool visible = m_chartAxis->isVisible();
                 setArrowVisibility(visible && m_chartAxis->isLineVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->linePen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
                 setTitleText(m_chartAxis->title());
             }
             void ChartAxis::setTitleText(const QString &title)
             {
                 if (m_titleText != title) {
                     m_titleText = title;
                     m_axisRect = QRect();
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 if (!m_titleText.isNull()) {
                     QFontMetrics fn(m_title->font());
                     int size(0);
                     if (orientation() == Qt::Horizontal)
                         size = grid.width();
                     else if (orientation() == Qt::Vertical)
                         size = grid.height();
                     if (fn.boundingRect(m_titleText).width() > size) {
                         QString string = m_titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                             string.remove(string.length() - 4, 1);
                         m_title->setText(string);
                     } else {
                         m_title->setText(m_titleText);
                     }
                     QPointF center = grid.center() - m_title->boundingRect().center();
                     if (orientation() == Qt::Horizontal) {
                         m_title->setPos(center.x(), m_axisRect.bottom() - m_title->boundingRect().height());
                     } else if (orientation() == Qt::Vertical) {
                         m_title->setTransformOriginPoint(m_title->boundingRect().center());
                         m_title->setRotation(270);
                         m_title->setPos(m_axisRect.left() - m_title->boundingRect().width() / 2 + m_title->boundingRect().height() / 2, center.y());
                     }
                 }
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::axisSelected()
             {
                 //TODO: axis clicked;
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_chartAxis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_chartAxis->alignment();
             }
             bool ChartAxis::isVisible()
             {
                 return m_chartAxis->isVisible();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QFontMetrics fn(m_title->font());
                 QSizeF sh;
                 if (m_titleText.isNull())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
                     if (orientation() == Qt::Horizontal)
                         sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     else if (orientation() == Qt::Vertical)
                         sh = QSizeF(fn.height(), fn.boundingRect("...").width());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
                     if (orientation() == Qt::Horizontal)
                         sh = QSizeF(fn.boundingRect(m_chartAxis->title()).width(), fn.height());
                     else if (orientation() == Qt::Vertical)
                         sh = QSizeF(fn.height(), fn.boundingRect(m_chartAxis->title()).width());
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             QStringList ChartAxis::createValueLabels(int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-qFloor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 QString format = axis->labelFormat();
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toAscii();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(const QString &format, int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-floor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/horizontalaxis.cpp +43 -21

             /****************************************************************************
             **
             ** 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, ChartPresenter *presenter, bool intervalAxis)
                 : ChartAxis(axis, presenter, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
-                QStringList ticksList = labels();
+                QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
-                Q_ASSERT(labels.size() == ticksList.size());
+                Q_ASSERT(labels.size() == labelList.size());
-                Q_ASSERT(layout.size() == ticksList.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());
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
+                    //items
-                    QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
+                    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
+                    //label text wrapping
-                    labelItem->setText(ticksList.at(i));
+                    if(intervalAxis()&& i+1!=layout.size()) {
-                    const QRectF &rect = labelItem->boundingRect();
+                        //wrapping in case of interval axis
+                        const qreal delta = layout[i+1] - layout[i];
+                        QString text = labelList.at(i);
+                        if (fn.boundingRect(text).width() > delta )
+                        {
+                            QString label = text + "...";
+                            while (fn.boundingRect(label).width() > delta && label.length() > 3)
+                            label.remove(label.length() - 4, 1);
+                            labelItem->setText(label);
+                        }
+                        else {
+                            labelItem->setText(text);
+                        }
+                    }else{
+                        labelItem->setText(labelList.at(i));
+                    }
+                    //label transformation origin point
+                    const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     //ticks and label position
                     if (alignment() == Qt::AlignTop) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() - 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());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
-                    if (intervalAxis() && i + 1 != layout.size()) {
+                    //label in beetwen
-                        const qreal delta = (layout[i + 1] - layout[i]) / 2;
+                    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());
                     }
-                    //overlap detection
+                    //label overlap detection
-                    if (labelItem->pos().x() <= width ||
+                    if(labelItem->pos().x() <= width ||
                         labelItem->pos().x() < axisRect.left() ||
                         labelItem->pos().x() + rect.width() > axisRect.right()) {
                         labelItem->setVisible(false);
-                        gridItem->setVisible(false);
-                        tickItem->setVisible(false);
+                    else {
-                    } else {
                         labelItem->setVisible(true);
-                        gridItem->setVisible(true);
+                        width=rect.width()+labelItem->pos().x();
-                        tickItem->setVisible(true);
-                        width = rect.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);
-                        if (intervalAxis() && (labelItem->pos().x() < gridRect.left() || labelItem->pos().x() + rect.width() > gridRect.right()))
+                    }else{
-                            labelItem->setVisible(false);
+                        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 = static_cast<QGraphicsLineItem *>(lines.at(layout.size() + 1));
+                    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);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx.cpp +12 -12

             /****************************************************************************
             **
             ** 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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, ChartPresenter *presenter)
                 : HorizontalAxis(axis, presenter),
                   m_tickCount(0), m_axis(axis)
             {
             }
             ChartValueAxisX::~ChartValueAxisX()
             {
             }
             QVector<qreal> ChartValueAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / (m_tickCount - 1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int x = i * deltaX + gridRect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(layout.size()));
                 HorizontalAxis::updateGeometry();
             }
             void ChartValueAxisX::handleAxisUpdated()
             {
                 if (m_tickCount != m_axis->tickCount()) {
                     m_tickCount = m_axis->tickCount();
                     presenter()->layout()->invalidate();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(m_tickCount);
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
-                case Qt::MinimumSize: {
+                case Qt::MinimumSize:{
-                    int count = qMax(ticksList.last().count(), ticksList.first().count());
+                    int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    count = qMin(count,5);
                     width = fn.averageCharWidth() * count;
                     height = fn.height() + labelPadding();
-                    width = qMax(width, base.width());
+                    width = qMax(width,base.width());
                     height += base.height();
-                    sh = QSizeF(width, height);
+                    sh = QSizeF(width,height);
                     break;
                 }
-                case Qt::PreferredSize: {
+                case Qt::PreferredSize:{
-                    for (int i = 0; i < ticksList.size(); ++i) {
+                    int count = qMax(ticksList.last().count(),ticksList.first().count());
-                        width += fn.averageCharWidth() * ticksList.at(i).count();
+                    width=fn.averageCharWidth() * count;
+                    height=fn.height()+labelPadding();
-                    height = fn.height() + labelPadding();
+                    width=qMax(width,base.width());
-                    width = qMax(width, base.width());
+                    height+=base.height();
-                    height += base.height();
+                    sh = QSizeF(width,height);
-                    sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** 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, ChartPresenter *presenter)
                 : VerticalAxis(axis, presenter),
                   m_tickCount(0),
                   m_axis(axis)
             {
             }
             ChartValueAxisY::~ChartValueAxisY()
             {
             }
             QVector<qreal> ChartValueAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / (m_tickCount - 1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int y = i * -deltaY + gridRect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(layout.size()));
                 VerticalAxis::updateGeometry();
             }
             void ChartValueAxisY::handleAxisUpdated()
             {
                 if (m_tickCount != m_axis->tickCount()) {
                     m_tickCount = m_axis->tickCount();
                     presenter()->layout()->invalidate();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(m_tickCount);
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
-                    int count = qMax(ticksList.first().count() , ticksList.last().count());
+                    width = fn.boundingRect("...").width() + labelPadding();
-                    width = fn.averageCharWidth() * count + labelPadding();
-                    height = fn.height();
-                    height = qMax(height, base.height());
                     width += base.width();
-                    sh = QSizeF(width, height);
+                    height = fn.height();
+                    height = qMax(height,base.height());
+                    sh = QSizeF(width,height);
                     break;
                 }
-                case Qt::PreferredSize: {
+                case Qt::PreferredSize:
-                    for (int i = 0; i < ticksList.size(); ++i) {
-                        width = qMax(qreal(fn.averageCharWidth() * ticksList.at(i).count()) + labelPadding(), width);
+                    int count = qMax(ticksList.first().count() , ticksList.last().count());
-                        height += fn.height();
+                    width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
-                    height = qMax(height, base.height());
                     width += base.width();
-                    sh = QSizeF(width, height);
+                    height = fn.height() * ticksList.count();
+                    height = qMax(height,base.height());
+                    sh = QSizeF(width,height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/verticalaxis.cpp +31 -21

             /****************************************************************************
             **
             ** 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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartAxis(axis, presenter, 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();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
-                if (alignment() == Qt::AlignLeft)
+                //arrow
-                    lineItem->setLine(axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
+                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                else if (alignment() == Qt::AlignRight)
-                    lineItem->setLine(axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
+                //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());
                 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
+                    //label text wrapping
                     QString text = labelList.at(i);
                     if (fn.boundingRect(text).width() > axisRect.right() - axisRect.left() - labelPadding()) {
                         QString label = text + "...";
                         while (fn.boundingRect(label).width() > axisRect.right() - axisRect.left() - labelPadding() && label.length() > 3)
                             label.remove(label.length() - 4, 1);
                         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());
                     //ticks and label position
                     if (alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() - 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());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
-                    if (intervalAxis() && i + 1 != layout.size()) {
-                        const qreal delta = (layout[i + 1] - layout[i]) / 2;
+                    //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());
                     }
-                    //overlap detection
+                    //label overlap detection
-                    if (labelItem->pos().y() + rect.height() > height ||
+                    if(labelItem->pos().y() + rect.height() > height ||
-                        labelItem->pos().y() + rect.height() > axisRect.bottom() ||
+                        labelItem->pos().y() + rect.height()/2 > gridRect.bottom() ||
-                        labelItem->pos().y() < axisRect.top()) {
+                        labelItem->pos().y() + rect.height()/2 < gridRect.top()) {
                         labelItem->setVisible(false);
-                        gridItem->setVisible(false);
-                        tickItem->setVisible(false);
+                    else {
-                    } else {
                         labelItem->setVisible(true);
-                        gridItem->setVisible(true);
+                        height=labelItem->pos().y();
-                        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()) {
+                    if ((y < gridRect.top() || y > gridRect.bottom()))
+                    {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
-                        if (intervalAxis() && (labelItem->pos().y() < gridRect.top() || labelItem->pos().y() + rect.height() > gridRect.bottom()))
+                    }else{
-                            labelItem->setVisible(false);
+                        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 = static_cast<QGraphicsLineItem *>(lines.at(layout.size() + 1));
+                    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);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout.cpp +54 -34

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

src/charttitle.cpp +2 -2

             /****************************************************************************
             **
             ** 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 "charttitle_p.h"
             #include <QFont>
             #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTitle::ChartTitle(QGraphicsItem *parent)
                 : QGraphicsSimpleTextItem(parent)
             {
             }
             ChartTitle::~ChartTitle()
             {
             }
             void ChartTitle::setText(const QString &text)
             {
                 m_text = text;
             }
             QString ChartTitle::text() const
             {
                 return m_text;
             }
             void ChartTitle::setGeometry(const QRectF &rect)
             {
                 QFontMetrics fn(font());
                 int width = rect.width();
                 if (fn.boundingRect(m_text).width() > width) {
                     QString string = m_text + "...";
                     while (fn.boundingRect(string).width() > width && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                     QGraphicsSimpleTextItem::setText(string);
                 } else {
                     QGraphicsSimpleTextItem::setText(m_text);
                 }
                 setPos(rect.topLeft());
             }
             QSizeF ChartTitle::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QFontMetrics fn(font());
                 QSizeF sh;
                 switch (which) {
                 case Qt::MinimumSize:
                     sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     break;
                 case Qt::PreferredSize:
-                    sh = QSizeF(fn.boundingRect(m_text).width(), fn.height());
+                    sh = fn.boundingRect(m_text).size();
                     break;
                 case Qt::MaximumSize:
-                    sh = QSizeF(fn.boundingRect(m_text).width(), fn.height());
+                    sh = fn.boundingRect(m_text).size();
                     break;
                 case Qt::MinimumDescent:
                     sh = QSizeF(0, fn.descent());
                     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