HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1965:8d7d66e44a18

Refactors layout...

Michal Klocek -

r1965:8d7d66e44a18

parent child

Context file:

r1965:8d7d66e44a18

Expand all files

src/charttitle.cpp created 644 +94 0

@@ -0,0 +1,94
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "charttitle_p.h"
	22	#include <QFont>
	23	#include <QFontMetrics>
	24	#include <QDebug>
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	ChartTitle::ChartTitle(QGraphicsItem* parent):QGraphicsSimpleTextItem(parent)
	29	{
	30
	31	}
	32
	33	ChartTitle::~ChartTitle()
	34	{
	35
	36	}
	37
	38	void ChartTitle::setText(const QString &text)
	39	{
	40	m_text=text;
	41	}
	42
	43	QString ChartTitle::text() const
	44	{
	45	return m_text;
	46	}
	47
	48	void ChartTitle::setGeometry(const QRectF &rect)
	49	{
	50	QFontMetrics fn(font());
	51
	52	int width = rect.width();
	53
	54	if (fn.boundingRect(m_text).width() > width)
	55	{
	56	QString string = m_text + "...";
	57	while (fn.boundingRect(string).width() > width && string.length() > 3)
	58	string.remove(string.length() - 4, 1);
	59	QGraphicsSimpleTextItem::setText(string);
	60	}
	61	else
	62	QGraphicsSimpleTextItem::setText(m_text);
	63
	64	setPos(rect.topLeft());
	65	}
	66
	67
	68	QSizeF ChartTitle::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	69	{
	70	Q_UNUSED(constraint);
	71	QFontMetrics fn (font ());
	72	QSizeF sh;
	73
	74	switch(which) {
	75	case Qt::MinimumSize:
	76	sh = QSizeF(fn.boundingRect ("...").width(),fn.height());
	77	break;
	78	case Qt::PreferredSize:
	79	sh = QSizeF(fn.boundingRect(m_text).width(),fn.height());
	80	break;
	81	case Qt::MaximumSize:
	82	sh = QSizeF(fn.boundingRect(m_text).width(),fn.height());
	83	break;
	84	case Qt::MinimumDescent:
	85	sh = QSizeF(0, fn.descent ());
	86	break;
	87	default:
	88	break;
	89	}
	90
	91	return sh;
	92	}
	93
	94	QTCOMMERCIALCHART_END_NAMESPACE

src/charttitle_p.h created 644 +53 0

@@ -0,0 +1,53
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef CHARTTITLE_P_H_
	31	#define CHARTTITLE_P_H_
	32
	33	#include "qchartglobal.h"
	34	#include <QGraphicsSimpleTextItem>
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class ChartTitle : public QGraphicsSimpleTextItem
	39	{
	40	public:
	41	ChartTitle(QGraphicsItem* parent = 0);
	42	~ChartTitle();
	43	QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
	44	void setText(const QString &text);
	45	QString text() const;
	46	void setGeometry(const QRectF &rect);
	47	private:
	48	QString m_text;
	49	};
	50
	51	QTCOMMERCIALCHART_END_NAMESPACE
	52
	53	#endif /* CHARTTITLE_P_H_ */

plugins/declarative/declarativechart.cpp +2 -1

             void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right)
             {
-                m_chart->setMinimumMargins(QMargins(left, top, right, bottom));
+                m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit minimumMarginsChanged();
                 emit plotAreaChanged(m_chart->plotArea());
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 qWarning() << "ChartView.bottomMargin is deprecated. Use minimumMargins and plotArea instead.";
                 return m_chart->plotArea().bottom();
             }

src/animations/axisanimation.cpp +3 -3

             #include "axisanimation_p.h"
             #include "chartaxis_p.h"
+            #include "chartpresenter_p.h"
             #include <QTimer>
             #include <QDebug>
                   switch (m_type) {
                   case ZoomOutAnimation: {
-                      QRectF rect = m_axis->geometry();
+                      QRectF rect = m_axis->presenter()->chartsGeometry();
                       oldLayout.resize(newLayout.count());
                       for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
                       break;
                   default: {
                       oldLayout.resize(newLayout.count());
-                      QRectF rect = m_axis->geometry();
+                      QRectF rect = m_axis->presenter()->chartsGeometry();
                       for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
                           oldLayout[i] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
                   }
                     Q_ASSERT(vector.count() != 0);
                     m_axis->setLayout(vector);
                     m_axis->updateGeometry();
-                    m_axis->checkLayout();
                 }
             }

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +62 -23

             #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
+            #include <QFontMetrics>
             #include <QDebug>
             #include <qmath.h>
                 QVector<qreal> points;
                 points.resize(count+2);
-                const qreal delta = m_rect.width()/(count);
+                QRectF rect = presenter()->chartsGeometry();
+                const qreal delta = rect.width()/(count);
                 qreal offset =-m_min-0.5;
                 if(delta<1) return points;
                 if(offset<=0) {
-                    offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta) + delta;
+                    offset = int(offset * rect.width()/(m_max - m_min))%int(delta) + delta;
                 }
                 else {
-                    offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta);
+                    offset = int(offset * rect.width()/(m_max - m_min))%int(delta);
                 }
-                points[0] = m_rect.left();
+                points[0] = rect.left();
-                points[count+1] = m_rect.right();
+                points[count+1] = rect.right();
                 for (int i = 0; i < count; ++i) {
-                    qreal x = offset + i * delta + m_rect.left();
+                    qreal x = offset + i * delta + rect.left();
                     points[i+1] = x;
                 }
                 return points;
             QStringList ChartBarCategoryAxisX::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
-                qreal d = (m_max - m_min)/m_rect.width();
+                QRectF rect = presenter()->chartsGeometry();
+                qreal d = (m_max - m_min)/rect.width();
                 for (int i = 0;i < layout.count()-1; ++i) {
-                    qreal x = qFloor((((layout[i+1] + layout[i])/2-m_rect.left())*d + m_min+0.5));
+                    qreal x = qFloor((((layout[i+1] + layout[i])/2-rect.left())*d + m_min+0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                const qreal delta = m_rect.width()/(m_categoriesAxis->d_ptr->count());
+                QRectF chartRect = presenter()->chartsGeometry();
+                const qreal delta =  chartRect.width()/(m_categoriesAxis->d_ptr->count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                lineItem->setLine( chartRect.left(),  chartRect.bottom(),  chartRect.right(),  chartRect.bottom());
-                qreal width = m_rect.left();
+                qreal width =  chartRect.left();
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
+                    lineItem->setLine(layout[i],  chartRect.top(), layout[i],  chartRect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if(i==0){
-                        labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i+1] - (delta)/2 - center.x(),  chartRect.bottom() + label_padding);
                     }else{
-                        labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] + (delta)/2 - center.x(),  chartRect.bottom() + label_padding);
                     }
-                    if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()>m_rect.right()) {
+                    if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()> chartRect.right()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         width=rect.width()+labelItem->pos().x();
                     }
-                    m_minWidth+=rect.width();
-                    m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
+                        rectItem->setRect(layout[i-1], chartRect.top(),layout[i]-layout[i-1], chartRect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
+                    lineItem->setLine(layout[i], chartRect.bottom(),layout[i], chartRect.bottom()+5);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_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()+label_padding;
+                        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()+label_padding,height);
+                        }
+                        width=qMax(width,base.width());
+                        height+=base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisx_p.h +1 -1

                 ~ChartBarCategoryAxisX();
                 AxisType axisType() const { return X_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +62 -23

             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include <qmath.h>
+            #include <QFontMetrics>
             #include <QDebug>
             static int label_padding = 5;
                 QVector<qreal> points;
                 points.resize(count+2);
-                const qreal delta = m_rect.height()/(count);
+                QRectF rect = presenter()->chartsGeometry();
+                const qreal delta = rect.height()/(count);
                 qreal offset = - m_min - 0.5;
                 if(delta<1) return points;
                 if(offset<=0) {
-                    offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta) + delta;
+                    offset = int(offset * rect.height()/(m_max - m_min))%int(delta) + delta;
                 }
                 else {
-                    offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta);
+                    offset = int(offset * rect.height()/(m_max - m_min))%int(delta);
                 }
-                points[0] = m_rect.bottom();
+                points[0] = rect.bottom();
-                points[count+1] = m_rect.top();
+                points[count+1] = rect.top();
                 for (int i = 0; i < count; ++i) {
-                    int y = m_rect.bottom() - i * delta - offset;
+                    int y = rect.bottom() - i * delta - offset;
                     points[i+1] = y;
                 }
                 return points;
             QStringList ChartBarCategoryAxisY::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
-                qreal d = (m_max - m_min)/m_rect.height();
+                QRectF rect = presenter()->chartsGeometry();
+                qreal d = (m_max - m_min)/rect.height();
                 for (int i = 0;i < layout.count()-1; ++i) {
-                    qreal x = qFloor(((m_rect.height()- (layout[i+1] + layout[i])/2 + m_rect.top())*d + m_min+0.5));
+                    qreal x = qFloor(((rect.height()- (layout[i+1] + layout[i])/2 + rect.top())*d + m_min+0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                const qreal delta = m_rect.height()/(m_categoriesAxis->d_ptr->count());
+                QRectF chartRect = presenter()->chartsGeometry();
+                const qreal delta = chartRect.height()/(m_categoriesAxis->d_ptr->count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
+                lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
-                qreal height = m_rect.bottom();
+                qreal height = chartRect.bottom();
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
+                    lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if(i==0) {
-                       labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
+                       labelItem->setPos(chartRect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
                     }
                     else {
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
+                        labelItem->setPos(chartRect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
                     }
-                    if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_rect.top()) {
+                    if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < chartRect.top()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         height=labelItem->pos().y();
                     }
-                    m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
-                    m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
+                        rectItem->setRect(chartRect.left(),layout[i],chartRect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
+                    lineItem->setLine(chartRect.left()-5,layout[i],chartRect.left(),layout[i]);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_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() + label_padding;
+                        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()+label_padding,width);
+                        }
+                        height=qMax(height,base.height());
+                        width+=base.width();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy_p.h +1 -1

                 ~ChartBarCategoryAxisY();
                 AxisType axisType() const { return Y_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/categoryaxis/chartcategoryaxisx.cpp +57 -19

                 if (tickCount < 2)
                     return points;
+                QRectF rect = presenter()->chartsGeometry();
                 qreal range = axis->max() - axis->min();
                 if (range > 0) {
                     points.resize(tickCount);
-                    qreal scale = m_rect.width() / range;
+                    qreal scale = rect.width() / range;
                     for (int i = 0; i < tickCount; ++i)
                         if (i < tickCount - 1) {
-                            int x = (axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + m_rect.left();
+                            int x = (axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.left();
                             points[i] = x;
                         } else {
-                            int x = (axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min())  * scale + m_rect.left();
+                            int x = (axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min())  * scale + rect.left();
                             points[i] = x;
                         }
                 }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                     labels.at(i)->setVisible(false);
                 }
+                QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
-                    // label items
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < layout.size() - 1) {
-                        labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), chartRect.bottom() + label_padding);
                     } else {
-                        labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
                     }
                     // check if the label should be shown
-                    if (labelItem->pos().x() + center.x() < m_rect.left() || labelItem->pos().x() + center.x() > m_rect.right())
+                    if (labelItem->pos().x() + center.x() < chartRect.left() || labelItem->pos().x() + center.x() > chartRect.right())
                         labelItem->setVisible(false);
                     else
                         labelItem->setVisible(true);
-                    m_minWidth += rect.width();
-                    m_minHeight = qMax(rect.height()+ label_padding, m_minHeight);
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
-                        rectItem->setRect(layout[i - 1],m_rect.top(),layout[i]-layout[i - 1],m_rect.height());
+                        rectItem->setRect(layout[i - 1],chartRect.top(),layout[i]-layout[i - 1],chartRect.height());
                     }
                     // grid lines and axis line ticks
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setPos(layout[i], m_rect.top());
+                    lineItem->setPos(layout[i], chartRect.top());
-                    lineItem->setLine(0, 0, 0, m_rect.height());
+                    lineItem->setLine(0, 0, 0, chartRect.height());
                     QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    tickLineItem->setPos(layout[i], m_rect.bottom());
+                    tickLineItem->setPos(layout[i], chartRect.bottom());
                     tickLineItem->setLine(0, 0, 0, 5);
                     // check if the grid line and the axis tick should be shown
-                    if (lineItem->pos().x() < m_rect.left() || lineItem->pos().x() > m_rect.right()) {
+                    if (lineItem->pos().x() < chartRect.left() || lineItem->pos().x() > chartRect.right()) {
                         lineItem->setVisible(false);
                         tickLineItem->setVisible(false);
                     } else {
                         lineItem->setVisible(true);
                         tickLineItem->setVisible(true);
                     }
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                QSizeF base = ChartAxis::sizeHint(which, constraint);
+                QStringList ticksList ; //TODO:
+                qreal width=0;
+                qreal height=0;
+                switch (which) {
+                    case Qt::MinimumSize:
+                    width = fn.boundingRect("...").width();
+                    height = fn.height() + label_padding;
+                    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()+label_padding,height);
+                        }
+                        width=qMax(width,base.width());
+                        height+=base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                    break;
+                }
+                return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisx_p.h +1 -1

                 ~ChartCategoryAxisX();
                 AxisType axisType() const { return X_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/categoryaxis/chartcategoryaxisy.cpp +57 -17

                 if (tickCount < 2)
                     return points;
+                QRectF rect = presenter()->chartsGeometry();
                 qreal range = axis->max() - axis->min();
                 if (range > 0) {
                     points.resize(tickCount);
-                    qreal scale = m_rect.height() / range;
+                    qreal scale = rect.height() / range;
                     for (int i = 0; i < tickCount; ++i)
                         if (i < tickCount - 1) {
-                            int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + m_rect.bottom();
+                            int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.bottom();
                             points[i] = y;
                         } else {
-                            int y = -(axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min())  * scale + m_rect.bottom();
+                            int y = -(axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min())  * scale + rect.bottom();
                             points[i] = y;
                         }
                 }
             void ChartCategoryAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) {
                     return;
                     labels.at(i)->setVisible(false);
                 }
+                QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
+                lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < layout.size() - 1)
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
+                        labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
                     else
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
+                        labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i]-center.y());
                     // check if the label should be shown
-                    if (labelItem->pos().y() + center.y() < m_rect.top() || labelItem->pos().y() + center.y() > m_rect.bottom())
+                    if (labelItem->pos().y() + center.y() < chartRect.top() || labelItem->pos().y() + center.y() > chartRect.bottom())
                         labelItem->setVisible(false);
                     else
                         labelItem->setVisible(true);
             //            height=labelItem->pos().y();
             //        }
-                    m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
-                    m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
+                        rectItem->setRect(chartRect.left(),layout[i],chartRect.width(),layout[i-1]-layout[i]);
                     }
                     // grid lines and axis line ticks
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setPos(m_rect.left(), layout[i]);
+                    lineItem->setPos(chartRect.left(), layout[i]);
-                    lineItem->setLine(0, 0, m_rect.width(), 0);
+                    lineItem->setLine(0, 0, chartRect.width(), 0);
                     QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    tickLineItem->setPos(m_rect.left(), layout[i]);
+                    tickLineItem->setPos(chartRect.left(), layout[i]);
                     tickLineItem->setLine(-5, 0, 0, 0);
                     // check if the grid line and the axis tick should be shown
-                    if (lineItem->pos().y() < m_rect.top() || lineItem->pos().y() > m_rect.bottom()) {
+                    if (lineItem->pos().y() < chartRect.top() || lineItem->pos().y() > chartRect.bottom()) {
                         lineItem->setVisible(false);
                         tickLineItem->setVisible(false);
                     } else {
                         lineItem->setVisible(true);
                         tickLineItem->setVisible(true);
                     }
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                QSizeF base = ChartAxis::sizeHint(which, constraint);
+                QStringList ticksList; //TODO::
+                qreal width=0;
+                qreal height=0;
+                  switch (which) {
+                    case Qt::MinimumSize:
+                        width = fn.boundingRect("...").width()+label_padding;
+                        height = fn.height();
+                        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));
+                            height+=rect.height();
+                            width=qMax(rect.width()+label_padding,width);
+                        }
+                        height=qMax(height,base.height());
+                        width+=base.width();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisy_p.h +1 -1

                 ~ChartCategoryAxisY();
                 AxisType axisType() const { return Y_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/chartaxis.cpp +119 -31

@@ -27,6 +27,7
27	#include <QDateTime>	27	#include <QDateTime>
28	#include <QValueAxis>	28	#include <QValueAxis>
29	#include <QGraphicsLayout>	29	#include <QGraphicsLayout>
		30	#include <QFontMetrics>
30		31
31	QTCOMMERCIALCHART_BEGIN_NAMESPACE	32	QTCOMMERCIALCHART_BEGIN_NAMESPACE
32		33
@@ -37,11 +38,10 ChartAxis::ChartAxis(QAbstractAxis axis,ChartPresenter presenter) : ChartEleme
37	m_shades(new QGraphicsItemGroup(presenter->rootItem())),	38	m_shades(new QGraphicsItemGroup(presenter->rootItem())),
38	m_labels(new QGraphicsItemGroup(presenter->rootItem())),	39	m_labels(new QGraphicsItemGroup(presenter->rootItem())),
39	m_arrow(new QGraphicsItemGroup(presenter->rootItem())),	40	m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
		41	m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
40	m_min(0),	42	m_min(0),
41	m_max(0),	43	m_max(0),
42	m_animation(0),	44	m_animation(0)
43	m_minWidth(0),
44	m_minHeight(0)
45	{	45	{
46	//initial initialization	46	//initial initialization
47	m_arrow->setZValue(ChartPresenter::AxisZValue);	47	m_arrow->setZValue(ChartPresenter::AxisZValue);
@@ -139,7 +139,6 void ChartAxis::updateLayout(QVector<qreal> &layout)
139	else {	139	else {
140	setLayout(layout);	140	setLayout(layout);
141	updateGeometry();	141	updateGeometry();
142	checkLayout();
143	}	142	}
144	}	143	}
145		144
@@ -231,7 +230,15 void ChartAxis::setLabelsFont(const QFont &font)
231	foreach(QGraphicsItem* item , m_labels->childItems()) {	230	foreach(QGraphicsItem* item , m_labels->childItems()) {
232	static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);	231	static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
233	}	232	}
234	m_font = ~~font~~;	233	if(m_font!=font) {
		234	m_font = font;
		235	foreach(QGraphicsItem* item , m_labels->childItems()) {
		236	static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
		237	}
		238	QGraphicsLayoutItem::updateGeometry();
		239	presenter()->layout()->invalidate();
		240
		241	}
235	}	242	}
236		243
237	void ChartAxis::setShadesBrush(const QBrush &brush)	244	void ChartAxis::setShadesBrush(const QBrush &brush)
@@ -264,7 +271,7 void ChartAxis::setGridPen(const QPen &pen)
264		271
265	bool ChartAxis::isEmpty()	272	bool ChartAxis::isEmpty()
266	{	273	{
267	return m_rect.isEmpty() \|\| qFuzzyIsNull(m_min - m_max);	274	return !m_rect.isValid() \|\| presenter()->chartsGeometry().isEmpty() \|\| qFuzzyIsNull(m_min - m_max);
268	}	275	}
269		276
270	void ChartAxis::handleDomainUpdated()	277	void ChartAxis::handleDomainUpdated()
@@ -289,8 +296,20 void ChartAxis::handleDomainUpdated()
289	m_max = max;	296	m_max = max;
290		297
291	if (!isEmpty()) {	298	if (!isEmpty()) {
		299
292	QVector<qreal> layout = calculateLayout();	300	QVector<qreal> layout = calculateLayout();
293	updateLayout(layout);	301	updateLayout(layout);
		302	QSizeF before = effectiveSizeHint(Qt::MinimumSize);
		303
		304	QSizeF after= sizeHint(Qt::MinimumSize);
		305
		306	if(before!=after) {
		307	QGraphicsLayoutItem::updateGeometry();
		308	//we don't want to call invalidate on layout, since it will change minimum size of component,
		309	//which we would like to avoid since it causes nasty flips when scrolling or zooming,
		310	//instead recalculate layout and use plotArea for extra space.
		311	presenter()->layout()->setGeometry(presenter()->layout()->geometry());
		312	}
294	}	313	}
295	}	314	}
296	}	315	}
@@ -314,7 +333,17 void ChartAxis::handleAxisUpdated()
314	setGridPen(m_chartAxis->gridLinePen());	333	setGridPen(m_chartAxis->gridLinePen());
315	setShadesPen(m_chartAxis->shadesPen());	334	setShadesPen(m_chartAxis->shadesPen());
316	setShadesBrush(m_chartAxis->shadesBrush());	335	setShadesBrush(m_chartAxis->shadesBrush());
		336	setTitleText(m_chartAxis->title());
		337	}
317		338
		339	void ChartAxis::setTitleText(const QString& title)
		340	{
		341	if(m_titleText!=title) {
		342	m_titleText = title;
		343	m_rect = QRect();
		344	QGraphicsLayoutItem::updateGeometry();
		345	presenter()->layout()->invalidate();
		346	}
318	}	347	}
319		348
320	void ChartAxis::hide()	349	void ChartAxis::hide()
@@ -325,42 +354,64 void ChartAxis::hide()
325	setShadesVisibility(false);	354	setShadesVisibility(false);
326	}	355	}
327		356
328	void ChartAxis::~~handle~~Geometry~~Changed~~(const QRectF &rect)	357	void ChartAxis::setGeometry(const QRectF &rect)
329	{	358	{
330	if(m_rect != rect)	359
331	{
332	m_rect = rect;	360	m_rect = rect;
		361
333	if (isEmpty()) return;	362	if (isEmpty()) return;
		363
		364	if(!m_titleText.isNull()) {
		365	QFontMetrics fn(m_title->font());
		366
		367	int size(0);
		368
		369	QRectF chartRect = presenter()->chartsGeometry();
		370
		371	if(orientation()==Qt::Horizontal)
		372	size = chartRect.width();
		373	else if(orientation()==Qt::Vertical)
		374	size = chartRect.height();
		375
		376	if (fn.boundingRect(m_titleText).width() > size)
		377	{
		378	QString string = m_titleText + "...";
		379	while (fn.boundingRect(string).width() > size && string.length() > 3)
		380	string.remove(string.length() - 4, 1);
		381	m_title->setText(string);
		382	}
		383	else
		384	m_title->setText(m_titleText);
		385
		386	QPointF center = chartRect.center() - m_title->boundingRect().center();
		387	if(orientation()==Qt::Horizontal) {
		388	m_title->setPos(center.x(),m_rect.bottom()-m_title->boundingRect().height());
		389	}
		390	else if(orientation()==Qt::Vertical) {
		391	m_title->setTransformOriginPoint(m_title->boundingRect().center());
		392	m_title->setRotation(270);
		393	m_title->setPos(m_rect.left()- m_title->boundingRect().width()/2+m_title->boundingRect().height()/2,center.y());
		394	}
		395	}
		396
334	QVector<qreal> layout = calculateLayout();	397	QVector<qreal> layout = calculateLayout();
335	updateLayout(layout);	398	updateLayout(layout);
336	}
337	}
338
339		399
340	qreal ChartAxis::minimumWidth()
341	{
342	if(m_minWidth == 0) updateGeometry();
343	return m_minWidth;
344	}	400	}
345		401
346	qreal ChartAxis::minimumHeight()
347	{
348	if(m_minHeight == 0) updateGeometry();
349	return m_minHeight;
350	}
351
352
353	void ChartAxis::axisSelected()	402	void ChartAxis::axisSelected()
354	{	403	{
355	~~qDebug~~()<<"TODO: axis clicked";	404	//TODO: axis clicked;
356	}	405	}
357		406
358		407
359	~~void~~ ChartAxis::createNumberLabels(~~QStringList~~ &~~labels~~,qreal min, qreal max, int ticks) const	408	QStringList ChartAxis::createNumberLabels(qreal min, qreal max, int ticks) const
360	{	409	{
361	Q_ASSERT(max>min);	410	Q_ASSERT(max>min);
362	Q_ASSERT(ticks>1);	411	Q_ASSERT(ticks>1);
363		412
		413	QStringList labels;
		414
364	int n = qMax(int(-qFloor(log10((max-min)/(ticks-1)))),0);	415	int n = qMax(int(-qFloor(log10((max-min)/(ticks-1)))),0);
365	n++;	416	n++;
366		417
@@ -381,17 +432,54 void ChartAxis::createNumberLabels(QStringList &labels,qreal min, qreal max, int
381	labels << QString().sprintf(array, value);	432	labels << QString().sprintf(array, value);
382	}	433	}
383	}	434	}
		435
		436	return labels;
384	}	437	}
385		438
386	void ChartAxis::checkLayout()	439	Qt::Orientation ChartAxis::orientation() const
387	{	440	{
388	if(m_minWidth > m_rect.width()) {	441	return m_chartAxis->orientation();
389	presenter()->layout()->invalidate();	442	}
390	}
391		443
392	if(m_minHeight > m_rect.height()) {	444	bool ChartAxis::isVisible()
393	presenter()->layout()->invalidate();	445	{
		446	return m_chartAxis->isVisible();
		447	}
		448
		449	QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
		450	{
		451
		452	Q_UNUSED(constraint);
		453	QFontMetrics fn(m_title->font());
		454	QSizeF sh;
		455
		456	if(m_titleText.isNull()) return sh;
		457
		458	switch(which) {
		459	case Qt::MinimumSize:
		460	if(orientation()==Qt::Horizontal) {
		461	sh = QSizeF(fn.boundingRect ("...").width(),fn.height());
		462	}
		463	else if(orientation()==Qt::Vertical) {
		464	sh = QSizeF(fn.height(),fn.boundingRect ("...").width());
		465	}
		466
		467	break;
		468	case Qt::MaximumSize:
		469	case Qt::PreferredSize:
		470	if(orientation()==Qt::Horizontal) {
		471	sh = QSizeF(fn.boundingRect(m_chartAxis->title()).width(),fn.height());
		472	}
		473	else if(orientation()==Qt::Vertical) {
		474	sh = QSizeF(fn.height(),fn.boundingRect(m_chartAxis->title()).width());
		475	}
		476
		477	break;
		478	default:
		479	break;
394	}	480	}
		481
		482	return sh;
395	}	483	}
396		484
397	#include "moc_chartaxis_p.cpp"	485	#include "moc_chartaxis_p.cpp"

src/axis/chartaxis_p.h +23 -11

             #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
+            class ChartAxis : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
+                Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 enum AxisType{ X_AXIS,Y_AXIS };
                 void setLabelsBrush(const QBrush &brush);
                 void setLabelsFont(const QFont &font);
+                void setTitlePen(const QPen &pen);
+                void setTitleBrush(const QBrush &brush);
+                void setTitleFont(const QFont &font);
+                void setTitleText(const QString& title);
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; };
-                QRectF geometry() const { return m_rect; }
+                Qt::Orientation orientation() const;
-                qreal minimumWidth();
-                qreal minimumHeight();
+                bool isVisible();
                 void hide();
+                void setGeometry(const QRectF &size);
+                QRectF geometry() const { return m_rect; }
+                virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const;
             protected:
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
-                void createNumberLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
+                QStringList createNumberLabels(qreal min, qreal max,int ticks) const;
-                void checkLayout();
             public Q_SLOTS:
                 virtual void handleAxisUpdated();
                 virtual void handleDomainUpdated();
-                void handleGeometryChanged(const QRectF &size);
             private:
                 inline bool isEmpty();
             protected:
                 QAbstractAxis* m_chartAxis;
-                QRectF m_rect;
                 int m_labelsAngle;
+                //TODO: to be removed
+                QRectF m_rect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
+                QGraphicsSimpleTextItem* m_title;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 AxisAnimation *m_animation;
-                qreal m_minWidth;
-                qreal m_minHeight;
                 QFont m_font;
+                QString m_titleText;
                 friend class AxisAnimation;
                 friend class AxisItem;

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +47 -13

                 QVector<qreal> points;
                 points.resize(m_tickCount);
+                QRectF rect = presenter()->chartsGeometry();
-                const qreal deltaX = m_rect.width()/(m_tickCount-1);
+                const qreal deltaX = rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
-                    int x = i * deltaX + m_rect.left();
+                    int x = i * deltaX + rect.left();
                     points[i] = x;
                 }
                 return points;
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
+                QRectF chartRect = presenter()->chartsGeometry();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
+                    lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
-                        m_minWidth+=rect.width();
-                        m_minHeight=qMax(rect.height(),m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
+                        rectItem->setRect(layout[i-1],chartRect.top(),layout[i]-layout[i-1],chartRect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
+                    lineItem->setLine(layout[i],chartRect.bottom(),layout[i],chartRect.bottom()+5);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                  switch (which) {
+                    case Qt::MinimumSize:
+                        sh = QSizeF(fn.boundingRect("...").width(),fn.height());
+                        break;
+                    case Qt::PreferredSize:{
+                        const QVector<qreal>& layout = ChartAxis::layout();
+                        if(layout.isEmpty()) break;
+                        QStringList ticksList;
+                        qreal width=0;
+                        qreal height=0;
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            width+=rect.width();
+                            height+=qMax(rect.height()+label_padding,height);
+                        }
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisx_p.h +1 -1

                 ~ChartDateTimeAxisX();
                 AxisType axisType() const { return X_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 void createLabels(QStringList &labels,qreal min, qreal max, int ticks);
                 void handleAxisUpdated();

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

                 QVector<qreal> points;
                 points.resize(m_tickCount);
+                QRectF rect = presenter()->chartsGeometry();
-                const qreal deltaY = m_rect.height()/(m_tickCount-1);
+                const qreal deltaY = rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
-                    int y = i * -deltaY + m_rect.bottom();
+                    int y = i * -deltaY + rect.bottom();
                     points[i] = y;
                 }
             void ChartDateTimeAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                qreal height =  2*m_rect.bottom();
+                QRectF chartRect = presenter()->chartsGeometry();
+                qreal height =  chartRect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
+                lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
+                    lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
+                        labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i]-center.y());
                         if(labelItem->pos().y()+rect.height()>height) {
                             labelItem->setVisible(false);
                             height=labelItem->pos().y();
                         }
-                        m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
-                        m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
+                        rectItem->setRect(chartRect.left(),layout[i],chartRect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
+                    lineItem->setLine(chartRect.left()-5,layout[i],chartRect.left(),layout[i]);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                  switch (which) {
+                    case Qt::MinimumSize:
+                        sh = QSizeF(fn.boundingRect("...").width(),fn.height());
+                        break;
+                    case Qt::PreferredSize:{
+                        const QVector<qreal>& layout = ChartAxis::layout();
+                        if(layout.isEmpty()) break;
+                        QStringList ticksList;
+                        qreal width=0;
+                        qreal height=0;
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            QRectF rect = fn.boundingRect(ticksList.at(i));
+                            width+=rect.width();
+                            height+=qMax(rect.height()+label_padding,height);
+                        }
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisy_p.h +1 -1

                 ~ChartDateTimeAxisY();
                 AxisType axisType() const { return Y_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 void createLabels(QStringList &labels,qreal min, qreal max, int ticks);
                 QVector<qreal> calculateLayout() const;

src/axis/qabstractaxis.cpp +84 0

@@ -458,6 +458,90 QColor QAbstractAxis::labelsColor() const
458	return d_ptr->m_labelsBrush.color();	458	return d_ptr->m_labelsBrush.color();
459	}	459	}
460		460
		461	void QAbstractAxis::setTitleVisible(bool visible)
		462	{
		463	if (d_ptr->m_titleVisible != visible) {
		464	d_ptr->m_titleVisible = visible;
		465	d_ptr->emitUpdated();
		466	}
		467	}
		468
		469	bool QAbstractAxis::titleVisible() const
		470	{
		471	return d_ptr->m_titleVisible;
		472	}
		473
		474	/*!
		475	Sets \a pen used to draw title.
		476	*/
		477	void QAbstractAxis::setTitlePen(const QPen &pen)
		478	{
		479	if (d_ptr->m_titlePen != pen) {
		480	d_ptr->m_titlePen = pen;
		481	d_ptr->emitUpdated();
		482	}
		483	}
		484
		485	/*!
		486	Returns the pen used to title.
		487	*/
		488	QPen QAbstractAxis::titlePen() const
		489	{
		490	return d_ptr->m_titlePen;
		491	}
		492
		493	/*!
		494	Sets \a brush used to draw title.
		495	*/
		496	void QAbstractAxis::setTitleBrush(const QBrush &brush)
		497	{
		498	if (d_ptr->m_titleBrush != brush) {
		499	d_ptr->m_titleBrush = brush;
		500	d_ptr->emitUpdated();
		501	}
		502	}
		503
		504	/*!
		505	Returns brush used to draw title.
		506	*/
		507	QBrush QAbstractAxis::titleBrush() const
		508	{
		509	return d_ptr->m_titleBrush;
		510	}
		511
		512	/*!
		513	Sets \a font used to draw title.
		514	*/
		515	void QAbstractAxis::setTitleFont(const QFont &font)
		516	{
		517	if (d_ptr->m_titleFont != font) {
		518	d_ptr->m_titleFont = font;
		519	d_ptr->emitUpdated();
		520	}
		521	}
		522
		523	/*!
		524	Returns font used to draw title.
		525	*/
		526	QFont QAbstractAxis::titleFont() const
		527	{
		528	return d_ptr->m_titleFont;
		529	}
		530
		531	void QAbstractAxis::setTitle(const QString& title)
		532	{
		533	if (d_ptr->m_title != title) {
		534	d_ptr->m_title = title;
		535	d_ptr->emitUpdated();
		536	}
		537	}
		538
		539	QString QAbstractAxis::title() const
		540	{
		541	return d_ptr->m_title;
		542	}
		543
		544
461	void QAbstractAxis::setShadesVisible(bool visible)	545	void QAbstractAxis::setShadesVisible(bool visible)
462	{	546	{
463	if (d_ptr->m_shadesVisible != visible) {	547	if (d_ptr->m_shadesVisible != visible) {

src/axis/qabstractaxis.h +13 0

@@ -98,6 +98,19 public:
98	void setLabelsColor(QColor color);	98	void setLabelsColor(QColor color);
99	QColor labelsColor() const;	99	QColor labelsColor() const;
100		100
		101	//title handling
		102	bool titleVisible() const;
		103	void setTitleVisible(bool visible = true);
		104	void setTitlePen(const QPen &pen);
		105	QPen titlePen() const;
		106	void setTitleBrush(const QBrush &brush);
		107	QBrush titleBrush() const;
		108	void setTitleFont(const QFont &font);
		109	QFont titleFont() const;
		110	void setTitle(const QString& title);
		111	QString title() const;
		112
		113
101	//shades handling	114	//shades handling
102	bool shadesVisible() const;	115	bool shadesVisible() const;
103	void setShadesVisible(bool visible = true);	116	void setShadesVisible(bool visible = true);

src/axis/qabstractaxis_p.h +6 0

                 QFont m_labelsFont;
                 int m_labelsAngle;
+                bool m_titleVisible;
+                QPen m_titlePen;
+                QBrush m_titleBrush;
+                QFont m_titleFont;
+                QString m_title;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;

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

             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
+            #include <QDebug>
             static int label_padding = 5;
                 QVector<qreal> points;
                 points.resize(m_tickCount);
-                const qreal deltaX = m_rect.width()/(m_tickCount-1);
+                QRectF rect = presenter()->chartsGeometry();
+                const qreal deltaX = rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
-                    int x = i * deltaX + m_rect.left();
+                    int x = i * deltaX + rect.left();
                     points[i] = x;
                 }
                 return points;
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QStringList ticksList;
+                QStringList ticksList = createNumberLabels(m_min,m_max,layout.size());
-                createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
+                QRectF chartRrect = presenter()->chartsGeometry();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                lineItem->setLine(chartRrect.left(), chartRrect.bottom(), chartRrect.right(), chartRrect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
+                    lineItem->setLine(layout[i], chartRrect.top(), layout[i], chartRrect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] - center.x(), chartRrect.bottom() + label_padding);
+                        if(labelItem->pos().x() <= width ||
-                        if(labelItem->pos().x()<=width){
+                           labelItem->pos().x() < m_rect.left() ||
+                           labelItem->pos().x() + rect.width() > m_rect.right()){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
-                        m_minWidth+=rect.width();
-                        m_minHeight=qMax(rect.height(),m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
+                        rectItem->setRect(layout[i-1],chartRrect.top(),layout[i]-layout[i-1],chartRrect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
+                    lineItem->setLine(layout[i],chartRrect.bottom(),layout[i],chartRrect.bottom()+5);
                 }
             }
             void ChartValueAxisX::handleAxisUpdated()
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                QSizeF base = ChartAxis::sizeHint(which, constraint);
+                QStringList ticksList = createNumberLabels(m_min,m_max,m_tickCount);
+                qreal width=0;
+                qreal height=0;
+                  switch (which) {
+                    case Qt::MinimumSize:{
+                        int count = qMax(ticksList.last().count(),ticksList.first().count());
+                        width=fn.averageCharWidth()*count;
+                        height=fn.height()+label_padding;
+                        width=qMax(width,base.width());
+                        height+=base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    case Qt::PreferredSize:{
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            width+=fn.averageCharWidth()*ticksList.at(i).count();
+                        }
+                        height=fn.height()+label_padding;
+                        width=qMax(width,base.width());
+                        height+=base.height();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                      break;
+                  }
+                  return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx_p.h +1 -1

                 ~ChartValueAxisX();
                 AxisType axisType() const { return X_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;

src/axis/valueaxis/chartvalueaxisy.cpp +69 -21

             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
+            #include <QDebug>
             static int label_padding = 5;
                 QVector<qreal> points;
                 points.resize(m_tickCount);
-                const qreal deltaY = m_rect.height()/(m_tickCount-1);
+                QRectF rect = presenter()->chartsGeometry();
+                const qreal deltaY = rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
-                    int y = i * -deltaY + m_rect.bottom();
+                    int y = i * -deltaY + rect.bottom();
                     points[i] = y;
                 }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                m_minWidth = 0;
-                m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QStringList ticksList;
+                QStringList ticksList = createNumberLabels(m_min,m_max,layout.size());
-                createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                qreal height =  2*m_rect.bottom();
+                QRectF chartRect = presenter()->chartsGeometry();
+                qreal height = m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
+                lineItem->setLine( chartRect.left() ,  chartRect.top(),  chartRect.left(),  chartRect.bottom());
+                QFontMetrics fn(m_font);
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
+                    lineItem->setLine( chartRect.left() , layout[i],  chartRect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                        labelItem->setText(ticksList.at(i));
+                        QString text = ticksList.at(i);
+                        if (fn.boundingRect(text).width() > chartRect.left() - m_rect.left() - label_padding )
+                        {
+                            QString label = text + "...";
+                            while (fn.boundingRect(label).width() > chartRect.left() - m_rect.left() - label_padding && label.length() > 3)
+                                    label.remove(label.length() - 4, 1);
+                            labelItem->setText(label);
+                        }else{
+                            labelItem->setText(text);
+                        }
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
+                        labelItem->setPos( chartRect.left() - rect.width() - label_padding , layout[i]-center.y());
-                        if(labelItem->pos().y()+rect.height()>height) {
+                        if(labelItem->pos().y() + rect.height() > height ||
+                            labelItem->pos().y() < m_rect.top()) {
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
+                        }else{
-                        else {
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             height=labelItem->pos().y();
                         }
-                        m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
-                        m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
-                        rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
+                        rectItem->setRect( chartRect.left(),layout[i], chartRect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                    lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
+                    lineItem->setLine( chartRect.left()-5,layout[i], chartRect.left(),layout[i]);
                 }
             }
             void ChartValueAxisY::handleAxisUpdated()
                 ChartAxis::handleAxisUpdated();
             }
+            QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            {
+                Q_UNUSED(constraint)
+                QFontMetrics fn(m_font);
+                QSizeF sh;
+                QSizeF base = ChartAxis::sizeHint(which, constraint);
+                QStringList ticksList = createNumberLabels(m_min,m_max,m_tickCount);
+                qreal width=0;
+                qreal height=0;
+                switch (which) {
+                    case Qt::MinimumSize: {
+                        int count = qMax(ticksList.first().count() , ticksList.last().count());
+                        width=fn.averageCharWidth()*count+label_padding;
+                        height=fn.height();
+                        height=qMax(height,base.height());
+                        width+=base.width();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    case Qt::PreferredSize:
+                    {
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
+                            width=qMax(qreal(fn.averageCharWidth()*ticksList.at(i).count())+label_padding,width);
+                            height+=fn.height();
+                        }
+                        height=qMax(height,base.height());
+                        width+=base.width();
+                        sh = QSizeF(width,height);
+                        break;
+                    }
+                    default:
+                    break;
+                }
+                return sh;
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy_p.h +1 -1

                 ~ChartValueAxisY();
                 AxisType axisType() const { return Y_AXIS;}
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/chartbackground_p.h 0 -1

             protected:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             private:
                 int roundness(qreal size) const;

src/chartlayout.cpp +159 -80

@@ -22,17 +22,20
22	#include "chartpresenter_p.h"	22	#include "chartpresenter_p.h"
23	#include "qlegend_p.h"	23	#include "qlegend_p.h"
24	#include "chartaxis_p.h"	24	#include "chartaxis_p.h"
		25	#include "charttitle_p.h"
		26	#include "chartbackground_p.h"
		27	#include "layoutdebuger_p.h"
		28	#include "legendmarker_p.h"
25	#include <QDebug>	29	#include <QDebug>
26		30
27	QTCOMMERCIALCHART_BEGIN_NAMESPACE	31	QTCOMMERCIALCHART_BEGIN_NAMESPACE
28		32
		33	static const qreal golden_ratio = 0.25;
		34
29	ChartLayout::ChartLayout(ChartPresenter* presenter):	35	ChartLayout::ChartLayout(ChartPresenter* presenter):
30	m_presenter(presenter),	36	m_presenter(presenter),
31	m_margin~~Big~~(60),	37	m_margins(20,20,20,20),
32	m_marginSmall(20),	38	m_minChartRect(0,0,200,200)
33	m_marginTiny(10),
34	m_chartMargins(m_marginBig,m_marginBig,m_marginBig,m_marginBig),
35	m_intialized(false)
36	{	39	{
37		40
38	}	41	}
@@ -44,137 +47,213 ChartLayout::~ChartLayout()
44		47
45	void ChartLayout::setGeometry(const QRectF& rect)	48	void ChartLayout::setGeometry(const QRectF& rect)
46	{	49	{
		50	Q_ASSERT(rect.isValid());
47		51
48	if (!rect.isValid()) return;	52	QList<ChartAxis*> axes = m_presenter->axisItems();
		53	ChartTitle* title = m_presenter->titleElement();
		54	QLegend* legend = m_presenter->legend();
		55	ChartBackground* background = m_presenter->backgroundElement();
49		56
50	QGraphicsLayout::setGeometry(rect);	57	QRectF contentGeometry = calculateBackgroundGeometry(rect,background);
51		58
52	if(!m_intialized){	59	contentGeometry = calculateContentGeometry(contentGeometry);
53	m_presenter->setGeometry(rect);
54	m_intialized=true;
55	}
56		60
57	// check title size	61	if (title && title->isVisible()) {
		62	contentGeometry = calculateTitleGeometry(contentGeometry,title);
		63	}
58		64
59	QSize titleSize = QSize(0,0);	65	if (legend->isAttachedToChart() && legend->isVisible()) {
		66	contentGeometry = calculateLegendGeometry(contentGeometry,legend);
		67	}
60		68
61	if (m_presenter->titleItem()) {	69	calculateChartGeometry(contentGeometry,axes);
62	titleSize= m_presenter->titleItem()->boundingRect().size().toSize();	70
		71	//TODO remove me
		72	#ifdef SHOW_LAYOUT
		73	LayoutDebuger* debuger = LayoutDebuger::instance();
		74	debuger->reset();
		75	debuger->setPen(QPen(Qt::red));
		76	debuger->add(backgroundGeometry,m_presenter->rootItem());
		77	debuger->add(titleGeometry,m_presenter->rootItem());
		78	debuger->add(legendGeometry ,m_presenter->rootItem());
		79	debuger->add(axisGeometry ,m_presenter->rootItem());
		80	debuger->add(geometry,m_presenter->rootItem());
		81	foreach(LegendMarker* marker,legend->d_ptr->markers()){
		82	debuger->add(marker->mapRectToScene(marker->boundingRect()),m_presenter->rootItem());
63	}	83	}
		84	#endif
		85
		86	QGraphicsLayout::setGeometry(rect);
		87	}
		88
		89	QRectF ChartLayout::calculateContentGeometry(const QRectF& geometry) const
		90	{
		91	return geometry.adjusted(m_margins.left(),m_margins.top(),-m_margins.right(),-m_margins.bottom());
		92	}
		93
		94	QRectF ChartLayout::calculateContentMinimum(const QRectF& minimum) const
		95	{
		96	return minimum.adjusted(0,0,m_margins.left()+m_margins.right(),m_margins.top() + m_margins.bottom());
		97	}
64		98
65	qreal axisHeight = 0;	99
66	qreal axisWidth = 0;	100	QRectF ChartLayout::calculateBackgroundGeometry(const QRectF& geometry,ChartBackground* background) const
		101	{
		102	qreal left, top, right, bottom;
		103	getContentsMargins(&left, &top, &right, &bottom);
		104	QRectF backgroundGeometry = geometry.adjusted(left,top,-right,-bottom);
		105	if(background) background->setRect(backgroundGeometry);
		106	return backgroundGeometry;
		107	}
		108
		109	QRectF ChartLayout::calculateBackgroundMinimum(const QRectF& minimum) const
		110	{
		111	qreal left, top, right, bottom;
		112	getContentsMargins(&left, &top, &right, &bottom);
		113	return minimum.adjusted(0,0,left + right,top+bottom);
		114	}
		115
		116	QRectF ChartLayout::calculateChartGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const
		117	{
		118
		119	QSizeF vertical(0,0);
		120	QSizeF horizontal(0,0);
67		121
68	// check axis size	122	// check axis size
		123	foreach(ChartAxis* axis , axes) {
		124	if(axis->orientation()==Qt::Vertical && axis->isVisible()) {
		125	vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
		126	}
		127	else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
		128	horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
		129	}
69		130
70	foreach (ChartAxis* axis,m_presenter->axisItems()){
71	if(axis->axisType() == ChartAxis::X_AXIS)
72	axisHeight = qMax(axis->minimumHeight(),axisHeight);
73	else
74	axisWidth = qMax(axis->minimumWidth(),axisWidth);
75	}	131	}
76		132
77	QLegend* legend = m_presenter->legend();	133	qreal width = qMin(vertical.width(),geometry.width() * golden_ratio);
78	Q_ASSERT(legend);
79		134
80	qreal titlePadding = m_chartMargins.top()/2;	135	QRectF rect = geometry.adjusted(width,vertical.height()/2,-horizontal.width()/2,-horizontal.height());
81		136
82	QMargins chartMargins = m_chartMargins;	137	m_presenter->setChartsGeometry(rect);
83		138
84	//TODO multiple axis handling;	139	foreach(ChartAxis* axis , axes) {
85	chartMargins.setLeft(qMax(m_chartMargins.left(),int(axisWidth + 2*m_marginTiny)));	140	axis->setGeometry(geometry);
86	chartMargins.setBottom(qMax(m_chartMargins.bottom(),int(axisHeight + 2* m_marginTiny)));	141	}
87		142
		143	return rect;
		144	}
88		145
89	// recalculate legend position	146	QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const
90	if ((legend->isAttachedToChart() && legend->isVisible())) {	147	{
		148	QSizeF vertical(0,0);
		149	QSizeF horizontal(0,0);
91		150
92	// Reserve some space for legend	151	// check axis size
93	switch (legend->alignment()) {	152	foreach(ChartAxis* axis , axes) {
		153	if(axis->orientation()==Qt::Vertical && axis->isVisible()){
		154	vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
		155	}else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
		156	horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
		157	}
		158	}
		159	return minimum.adjusted(0,0,horizontal.width()+vertical.width(),horizontal.height() + vertical.height());
		160	}
94		161
95	case Qt::AlignTop: {	162	QRectF ChartLayout::calculateLegendGeometry(const QRectF& geometry,QLegend* legend) const
		163	{
		164	QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,-1));
		165	QRectF legendRect;
		166	QRectF result;
96		167
97	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));	168	switch (legend->alignment()) {
98	int topMargin = 2*m_marginTiny + titleSize.height() + legendSize.height() + m_marginTiny;	169
99	chartMargins = QMargins(chartMargins.left(),topMargin,chartMargins.right(),chartMargins.bottom());	170	case Qt::AlignTop: {
100	m_legendMargins = QMargins(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny),chartMargins.right(),rect.height()-topMargin + m_marginTiny);	171	legendRect = QRectF(geometry.topLeft(),QSizeF(geometry.width(),size.height()));
101	titlePadding = m_marginTiny + m_marginTiny;	172	result = geometry.adjusted(0,legendRect.height(),0,0);
102	break;	173	break;
103	}	174	}
104	case Qt::AlignBottom: {	175	case Qt::AlignBottom: {
105	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));	176	legendRect = QRectF(QPointF(geometry.left(),geometry.bottom()-size.height()),QSizeF(geometry.width(),size.height()));
106	int bottomMargin = m_marginTiny + legendSize.height() + m_marginTiny + axisHeight;	177	result = geometry.adjusted(0,0,0,-legendRect.height());
107	chartMargins = QMargins(chartMargins.left(),chartMargins.top(),chartMargins.right(),bottomMargin);
108	m_legendMargins = QMargins(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight,chartMargins.right(),m_marginTiny + m_marginSmall);
109	titlePadding = chartMargins.top()/2;
110	break;	178	break;
111	}	179	}
112	case Qt::AlignLeft: {	180	case Qt::AlignLeft: {
113	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));	181	qreal width = qMin(size.width(),geometry.width()*golden_ratio);
114	int leftPadding = m_marginTiny + legendSize.width() + m_marginTiny + axisWidth;	182	legendRect = QRectF(geometry.topLeft(),QSizeF(width,geometry.height()));
115	chartMargins = QMargins(leftPadding,chartMargins.top(),chartMargins.right(),chartMargins.bottom());	183	result = geometry.adjusted(width,0,0,0);
116	m_legendMargins = QMargins(m_marginTiny + m_marginSmall,chartMargins.top(),rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom());
117	titlePadding = chartMargins.top()/2;
118	break;	184	break;
119	}	185	}
120	case Qt::AlignRight: {	186	case Qt::AlignRight: {
121	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));	187	qreal width = qMin(size.width(),geometry.width()*golden_ratio);
122	int rightPadding = m_marginTiny + legendSize.width() + m_marginTiny;	188	legendRect = QRectF(QPointF(geometry.right()-width,geometry.top()),QSizeF(width,geometry.height()));
123	chartMargins = QMargins(chartMargins.left(),chartMargins.top(),rightPadding,chartMargins.bottom());	189	result = geometry.adjusted(0,0,-width,0);
124	m_legendMargins = QMargins(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top(),m_marginTiny + m_marginSmall,chartMargins.bottom());
125	titlePadding = chartMargins.top()/2;
126	break;	190	break;
127	}	191	}
128	default: {	192	default: {
129	break;	193	break;
130	}	194	}
131	}
132
133	legend->setGeometry(rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
134	}	195	}
135		196
136	// recalculate title position	197	legend->setGeometry(legendRect);
137	if (m_presenter->titleItem()) {
138	QPointF center = rect.center() - m_presenter->titleItem()->boundingRect().center();
139	m_presenter->titleItem()->setPos(center.x(),titlePadding);
140	}
141		198
142	//recalculate background gradient	199	return result;
143	if (m_presenter->backgroundItem()) {	200	}
144	m_presenter->backgroundItem()->setRect(rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
145	}
146		201
147	QRectF chartRect = rect.adjusted(chartMargins.left(),chartMargins.top(),-chartMargins.right(),-chartMargins.bottom());	202	QRectF ChartLayout::calculateLegendMinimum(const QRectF& geometry,QLegend* legend) const
		203	{
		204	QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize,QSizeF(-1,-1));
		205	return geometry.adjusted(0,0,minSize.width(),minSize.height());
		206	}
148		207
149	if(m_presenter->geometry()!=chartRect && chartRect.isValid()){	208	QRectF ChartLayout::calculateTitleGeometry(const QRectF& geometry,ChartTitle* title) const
150	m_presenter->setGeometry(chartRect);	209	{
151	}else if(chartRect.size().isEmpty()){	210	title->setGeometry(geometry);
152	m_presenter->setGeometry(QRect(rect.width()/2,rect.height()/2,1,1));	211	QPointF center = geometry.center() - title->boundingRect().center();
153	}	212	title->setPos(center.x(),title->pos().y());
		213	return geometry.adjusted(0,title->boundingRect().height(),0,0);
154	}	214	}
155		215
		216	QRectF ChartLayout::calculateTitleMinimum(const QRectF& minimum,ChartTitle* title) const
		217	{
		218	QSizeF min = title->sizeHint(Qt::MinimumSize);
		219	return minimum.adjusted(0,0,min.width(),min.height());
		220	}
156		221
157	QSizeF ChartLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const	222	QSizeF ChartLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
158	{	223	{
159	Q_UNUSED(constraint);	224	Q_UNUSED(constraint);
160	if(which == Qt::MinimumSize)	225	if(which == Qt::MinimumSize){
161	return QSize(2(m_chartMargins.top()+m_chartMargins.bottom()),2(m_chartMargins.top() + m_chartMargins.bottom()));	226	QList<ChartAxis*> axes = m_presenter->axisItems();
162	else	227	ChartTitle* title = m_presenter->titleElement();
		228	QLegend* legend = m_presenter->legend();
		229	QRectF minimumRect(0,0,0,0);
		230	minimumRect = calculateBackgroundMinimum(minimumRect);
		231	minimumRect = calculateContentMinimum(minimumRect);
		232	minimumRect = calculateTitleMinimum(minimumRect,title);
		233	minimumRect = calculateLegendMinimum(minimumRect,legend);
		234	minimumRect = calculateAxisMinimum(minimumRect,axes);
		235	return minimumRect.united(m_minChartRect).size().toSize();
		236	}else
163	return QSize(-1,-1);	237	return QSize(-1,-1);
164	}	238	}
165		239
166	void ChartLayout::setM~~inimumM~~argins(const QMargins& margins)	240	void ChartLayout::setMargins(const QMargins& margins)
167	{	241	{
168		242
169	if(m_~~chartM~~argins != margins){	243	if(m_margins != margins){
170	m_~~chartM~~argins = margins;	244	m_margins = margins;
171	updateGeometry();	245	updateGeometry();
172	}	246	}
173	}	247	}
174		248
175	QMargins ChartLayout::m~~inimumM~~argins() const	249	QMargins ChartLayout::margins() const
		250	{
		251	return m_margins;
		252	}
		253
		254	void ChartLayout::adjustChartGeometry()
176	{	255	{
177	return m_chartMargins;	256	setGeometry(geometry());
178	}	257	}
179		258
180	QTCOMMERCIALCHART_END_NAMESPACE	259	QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout_p.h +22 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
+            class ChartTitle;
+            class QLegend;
+            class ChartAxis;
+            class ChartBackground;
             class ChartLayout : public QGraphicsLayout
             {
                 ChartLayout(ChartPresenter* presenter);
                 virtual ~ChartLayout();
-                void setMinimumMargins(const QMargins& margins);
+                void setMargins(const QMargins& margins);
-                QMargins minimumMargins() const;
+                QMargins margins() const;
                 void setGeometry(const QRectF& rect);
+                void adjustChartGeometry();
             protected:
                 QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
                 void removeAt(int){};
             private:
-                ChartPresenter* m_presenter;
+                QRectF calculateBackgroundGeometry(const QRectF& geometry,ChartBackground* background) const;
-                int m_marginBig;
+                QRectF calculateContentGeometry(const QRectF& geometry) const;
-                int m_marginSmall;
+                QRectF calculateTitleGeometry(const QRectF& geometry, ChartTitle* title) const;
-                int m_marginTiny;
+                QRectF calculateChartGeometry(const QRectF& geometry,const QList<ChartAxis*>& axes) const;
-                QMargins m_chartMargins;
+                QRectF calculateLegendGeometry(const QRectF& geometry, QLegend* legend) const;
-                QMargins m_legendMargins;
+                QRectF calculateBackgroundMinimum(const QRectF& minimum) const;
-                bool m_intialized;
+                QRectF calculateContentMinimum(const QRectF& minimum) const;
+                QRectF calculateTitleMinimum(const QRectF& minimum,ChartTitle* title) const;
+                QRectF calculateAxisMinimum(const QRectF& minimum,const QList<ChartAxis*>& axes) const;
+                QRectF calculateLegendMinimum(const QRectF& minimum,QLegend* legend) const;
+            private:
+                ChartPresenter* m_presenter;
+                QMargins m_margins;
+                QRectF m_minChartRect;
+                QRectF m_minAxisRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +71 -64

             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
-            //#include "chartaxisx_p.h"
-            //#include "chartaxisy_p.h"
-            #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             #include "chartlayout_p.h"
+            #include "charttitle_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             m_options(QChart::NoAnimation),
             m_state(ShowState),
             m_layout(new ChartLayout(this)),
-            m_backgroundItem(0),
+            m_background(0),
-            m_titleItem(0)
+            m_title(0)
             {
             }
                 delete m_chartTheme;
             }
-            void ChartPresenter::setGeometry(const QRectF& rect)
+            void ChartPresenter::setChartsGeometry(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
-                if(m_rect!=rect) {
+                if(m_chartsRect!=rect) {
-                       m_rect=rect;
+                    m_chartsRect=rect;
-                       emit geometryChanged(m_rect);
+                    foreach(ChartElement* chart, m_chartItems)
+                    {
+                        chart->handleGeometryChanged(rect);
+                    }
                 }
             }
+            QRectF ChartPresenter::chartsGeometry() const
+            {
+                return m_chartsRect;
+            }
             void ChartPresenter::handleAxisAdded(QAbstractAxis* axis,Domain* domain)
             {
                 ChartAxis* item = axis->d_ptr->createGraphics(this);
                 m_chartTheme->decorate(axis);
                 axis->d_ptr->setDirty(false);
                 axis->d_ptr->emitUpdated();
-                if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
+                if(m_chartsRect.isValid()) item->handleGeometryChanged(m_chartsRect);
                 m_axisItems.insert(axis, item);
                 selectVisibleAxis();
                 //initialize
                 item->handleDomainUpdated();
-                if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
+                if(m_chartsRect.isValid()) item->handleGeometryChanged(m_chartsRect);
                 m_chartItems.insert(series,item);
             }
                           handleSeriesRemoved(series);
                           handleSeriesAdded(series,domain);
                    }
+                   layout()->invalidate();
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
-                QRectF rect = geometry();
+                QRectF rect = chartsGeometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
-                rect.moveCenter(geometry().center());
+                rect.moveCenter(chartsGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
-                r.translate(-geometry().topLeft());
+                r.translate(-chartsGeometry().topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
-                m_statePoint = QPointF(r.center().x()/geometry().width(),r.center().y()/geometry().height());
+                m_statePoint = QPointF(r.center().x()/chartsGeometry().width(),r.center().y()/chartsGeometry().height());
-                m_dataset->zoomInDomain(r,geometry().size());
+                m_dataset->zoomInDomain(r,chartsGeometry().size());
                 m_state = ShowState;
             }
                 m_state = ZoomOutState;
                 QRectF chartRect;
-                chartRect.setSize(geometry().size());
+                chartRect.setSize(chartsGeometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
-                m_statePoint = QPointF(rect.center().x()/geometry().width(),rect.center().y()/geometry().height());
+                m_statePoint = QPointF(rect.center().x()/chartsGeometry().width(),rect.center().y()/chartsGeometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
-                m_dataset->scrollDomain(dx,dy,geometry().size());
+                m_dataset->scrollDomain(dx,dy,chartsGeometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::createBackgroundItem()
             {
-                if (!m_backgroundItem) {
+                if (!m_background) {
-                    m_backgroundItem = new ChartBackground(rootItem());
+                    m_background = new ChartBackground(rootItem());
-                    m_backgroundItem->setPen(Qt::NoPen);
+                    m_background->setPen(Qt::NoPen);
-                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
+                    m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
-                if (!m_titleItem) {
+                if (!m_title) {
-                    m_titleItem = new QGraphicsSimpleTextItem(rootItem());
+                    m_title = new ChartTitle(rootItem());
-                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
+                    m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
-            QGraphicsRectItem* ChartPresenter::backgroundItem()
-                return m_backgroundItem;
             void ChartPresenter::setBackgroundBrush(const QBrush& brush)
             {
                 createBackgroundItem();
-                m_backgroundItem->setBrush(brush);
+                m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
-                if (!m_backgroundItem) return QBrush();
+                if (!m_background) return QBrush();
-                return m_backgroundItem->brush();
+                return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen& pen)
             {
                 createBackgroundItem();
-                m_backgroundItem->setPen(pen);
+                m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
-                if (!m_backgroundItem) return QPen();
+                if (!m_background) return QPen();
-                return m_backgroundItem->pen();
+                return m_background->pen();
-            QGraphicsItem* ChartPresenter::titleItem()
-                return m_titleItem;
             }
             void ChartPresenter::setTitle(const QString& title)
             {
                 createTitleItem();
-                m_titleItem->setText(title);
+                m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
-                if (!m_titleItem) return QString();
+                if (!m_title) return QString();
-                return m_titleItem->text();
+                return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont& font)
             {
                 createTitleItem();
-                m_titleItem->setFont(font);
+                m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
-                if (!m_titleItem)  return QFont();
+                if (!m_title)  return QFont();
-                return m_titleItem->font();
+                return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
-                m_titleItem->setBrush(brush);
+                m_title->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
-                if (!m_titleItem) return QBrush();
+                if (!m_title) return QBrush();
-                return m_titleItem->brush();
+                return m_title->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
-                m_backgroundItem->setVisible(visible);
+                m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
-                if (!m_backgroundItem) return false;
+                if (!m_background) return false;
-                return m_backgroundItem->isVisible();
+                return m_background->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
-                m_backgroundItem->setDropShadowEnabled(enabled);
+                m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
-                if (!m_backgroundItem) return false;
+                if (!m_background) return false;
-                return m_backgroundItem->isDropShadowEnabled();
+                return m_background->isDropShadowEnabled();
             }
                 return m_layout;
             }
-            void ChartPresenter::setMinimumMargins(const QMargins& margins)
+            void ChartPresenter::setMargins(const QMargins& margins)
             {
-                m_layout->setMinimumMargins(margins);
+                m_layout->setMargins(margins);
             }
-            QMargins ChartPresenter::minimumMargins() const
+            QMargins ChartPresenter::margins() const
             {
-                return m_layout->minimumMargins();
+                return m_layout->margins();
             }
             QLegend* ChartPresenter::legend()
                 return m_chart->legend();
             }
+            void ChartPresenter::setVisible(bool visible)
+            {
+                m_chart->setVisible(visible);
+            }
+            ChartBackground* ChartPresenter::backgroundElement()
+            {
+                return m_background;
+            }
             QList<ChartAxis*>  ChartPresenter::axisItems() const
             {
                 return m_axisItems.values();
             }
-            void ChartPresenter::setVisible(bool visible)
+            ChartTitle* ChartPresenter::titleElement()
             {
-                m_chart->setVisible(visible);
+                return m_title;
             }
             #include "moc_chartpresenter_p.cpp"

src/chartpresenter_p.h +10 -9

             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
+            class ChartTitle;
             class ChartAnimation;
             class ChartLayout;
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
-                QGraphicsRectItem* backgroundItem();
+                ChartBackground* backgroundElement();
-                QGraphicsItem* titleItem();
+                ChartTitle* titleElement();
                 QList<ChartAxis*> axisItems() const;
                 QLegend* legend();
                 void zoomOut(qreal factor);
                 void scroll(qreal dx,qreal dy);
-                void setGeometry(const QRectF& rect);
+                void setChartsGeometry(const QRectF& rect);
-                QRectF geometry() { return m_rect; }
+                QRectF chartsGeometry() const;
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 void resetAllElements();
-                void setMinimumMargins(const QMargins& margins);
+                void setMargins(const QMargins& margins);
-                QMargins minimumMargins() const;
+                QMargins margins() const;
                 QGraphicsLayout* layout();
             private:
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries*, ChartElement*> m_chartItems;
                 QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
-                QRectF m_rect;
+                QRectF m_chartsRect;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
                 ChartLayout* m_layout;
-                ChartBackground* m_backgroundItem;
+                ChartBackground* m_background;
-                QGraphicsSimpleTextItem* m_titleItem;
+                ChartTitle* m_title;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain.cpp 0 -1

                 }else if(axis->orientation()==Qt::Vertical){
                     setRangeY(axis->min(),axis->max());
                 }
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)

src/legend/legendlayout.cpp +63 -55

             #include "chartpresenter_p.h"
             #include "legendmarker_p.h"
             #include "qlegend_p.h"
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 }
                 QRectF boundingRect = geometry();
+                qreal left, top, right, bottom;
+                getContentsMargins(&left, &top, &right, &bottom);
+                boundingRect.adjust(left,top,-right,-bottom);
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                 m_width=0;
                 m_height=0;
+                qreal left, top, right, bottom;
+                getContentsMargins(&left, &top, &right, &bottom);
+                QRectF geometry = rect.adjusted(left,top,-right,-bottom);
                 switch(m_legend->alignment()) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         QPointF point(0,0);
                         foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
-                                marker->setPos(point.x(),rect.height()/2 - marker->boundingRect().height()/2);
+                                marker->setPos(point.x(),geometry.height()/2 - marker->boundingRect().height()/2);
                                 const QRectF& rect = marker->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 point.setX(point.x() + w);
                             }
                         }
-                        if(m_width<rect.width()) {
+                        if(m_width<geometry.width()) {
-                            m_legend->d_ptr->items()->setPos(rect.width()/2-m_width/2,rect.top());
+                            m_legend->d_ptr->items()->setPos(geometry.width()/2-m_width/2,geometry.top());
                         }
                         else {
-                            m_legend->d_ptr->items()->setPos(rect.topLeft());
+                            m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         }
                         m_height=size.height();
                     }
                         QPointF point(0,0);
                         foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
                                 marker->setPos(point);
                                 const QRectF& rect = marker->boundingRect();
                                 qreal h = rect.height();
                                 point.setY(point.y() + h);
                             }
                         }
-                        if(m_height<rect.height()) {
+                        if(m_height<geometry.height()) {
-                            m_legend->d_ptr->items()->setPos(rect.left(),rect.height()/2-m_height/2);
+                            m_legend->d_ptr->items()->setPos(geometry.left(),geometry.height()/2-m_height/2);
                         }
                         else {
-                            m_legend->d_ptr->items()->setPos(rect.topLeft());
+                            m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         }
                         m_width=size.width();
                     }
                     break;
                 }
-                m_minOffsetX = 0;
-                m_minOffsetY = 0;
+                m_minOffsetX = -left;
-                m_maxOffsetX = m_width - rect.width();
+                m_minOffsetY = - top;
-                m_maxOffsetY = m_height - rect.height();
+                m_maxOffsetX = m_width - geometry.width() - right;
+                m_maxOffsetY = m_height - geometry.height() - bottom;
             }
             void LegendLayout::setDettachedGeometry(const QRectF& rect)
                 m_offsetX=0;
                 m_offsetY=0;
+                qreal left, top, right, bottom;
+                getContentsMargins(&left, &top, &right, &bottom);
+                QRectF geometry = rect.adjusted(left,top,-right,-bottom);
                 QSizeF size(0,0);
                 QList<LegendMarker *> markers = m_legend->d_ptr->markers();
                 switch (m_legend->alignment()) {
                     case Qt::AlignTop: {
-                        QPointF point = rect.topLeft();
+                        QPointF point(0,0);
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<markers.count(); i++) {
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
                                 marker->setPos(point.x(),point.y());
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 m_width = qMax(m_width,w);
                                 m_height = qMax(m_height,h);
                                 point.setX(point.x() + w);
-                                if (point.x() + w > rect.topLeft().x() + rect.width()) {
+                                if (point.x() + w > geometry.left() + geometry.width() - right) {
                                     // Next item would go off rect.
-                                    point.setX(rect.topLeft().x());
+                                    point.setX(0);
                                     point.setY(point.y() + h);
                                     if (i+1 < markers.count()) {
                                         m_height += h;
                                 }
                             }
                         }
-                        m_legend->d_ptr->items()->setPos(rect.topLeft());
+                        m_legend->d_ptr->items()->setPos(geometry.topLeft());
-                        m_minOffsetX = 0;
+                        m_minOffsetX = -left;
-                        m_minOffsetY = 0;
+                        m_minOffsetY = -top;
-                        m_maxOffsetX = m_width - rect.width();
+                        m_maxOffsetX = m_width - geometry.width() - right;
-                        m_maxOffsetY = m_height - rect.height();
+                        m_maxOffsetY = m_height - geometry.height() - bottom;
                     }
                     break;
                     case Qt::AlignBottom: {
-                        QPointF point = rect.bottomLeft();
+                        QPointF point(0,geometry.height());
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<markers.count(); i++) {
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height,h);
                                 marker->setPos(point.x(),point.y() - h);
                                 point.setX(point.x() + w);
-                                if (point.x() + w > rect.bottomLeft().x() + rect.width()) {
+                                if (point.x() + w > geometry.left() + geometry.width() - right) {
                                     // Next item would go off rect.
-                                    point.setX(rect.bottomLeft().x());
+                                    point.setX(0);
                                     point.setY(point.y() - h);
                                     if (i+1 < markers.count()) {
                                         m_height += h;
                                 }
                             }
                         }
-                        m_legend->d_ptr->items()->setPos(rect.topLeft());
+                        m_legend->d_ptr->items()->setPos(geometry.topLeft());
-                        m_minOffsetX = 0;
+                        m_minOffsetX = -left;
-                        m_minOffsetY = qMin(rect.topLeft().y(), rect.topLeft().y() - m_height + rect.height());
+                        m_minOffsetY = -m_height + geometry.height() - top;
-                        m_maxOffsetX = m_width - rect.width();
+                        m_maxOffsetX = m_width - geometry.width() - right;
-                        m_maxOffsetY = 0;
+                        m_maxOffsetY = -bottom;
                     }
                     break;
                     case Qt::AlignLeft: {
-                        QPointF point = rect.topLeft();
+                        QPointF point(0,0);
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<markers.count(); i++) {
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 maxWidth = qMax(maxWidth,w);
                                 marker->setPos(point.x(),point.y());
                                 point.setY(point.y() + h);
-                                if (point.y() + h > rect.topLeft().y() + rect.height()) {
+                                if (point.y() + h > geometry.bottom() - bottom) {
                                     // Next item would go off rect.
                                     point.setX(point.x() + maxWidth);
-                                    point.setY(rect.topLeft().y());
+                                    point.setY(0);
                                     if (i+1 < markers.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                             }
                         }
                         m_width += maxWidth;
-                        m_legend->d_ptr->items()->setPos(rect.topLeft());
+                        m_legend->d_ptr->items()->setPos(geometry.topLeft());
-                        m_minOffsetX = 0;
+                        m_minOffsetX = -left;
-                        m_minOffsetY = 0;
+                        m_minOffsetY = -top;
-                        m_maxOffsetX = m_width - rect.width();
+                        m_maxOffsetX = m_width - geometry.width() - right;
-                        m_maxOffsetY = m_height - rect.height();
+                        m_maxOffsetY = m_height - geometry.height() - bottom;
                     }
                     break;
                     case Qt::AlignRight: {
-                        QPointF point = rect.topRight();
+                        QPointF point(geometry.width(),0);
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<markers.count(); i++) {
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
-                                marker->setGeometry(QRectF(QPointF(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
+                                marker->setGeometry(geometry);
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 maxWidth = qMax(maxWidth,w);
                                 marker->setPos(point.x() - w,point.y());
                                 point.setY(point.y() + h);
-                                if (point.y() + h > rect.topLeft().y() + rect.height()) {
+                                if (point.y() + h > geometry.bottom()-bottom) {
                                     // Next item would go off rect.
                                     point.setX(point.x() - maxWidth);
-                                    point.setY(rect.topLeft().y());
+                                    point.setY(0);
                                     if (i+1 < markers.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                             }
                         }
                         m_width += maxWidth;
-                        m_legend->d_ptr->items()->setPos(rect.topLeft());
+                        m_legend->d_ptr->items()->setPos(geometry.topLeft());
-                        m_minOffsetX = qMin(rect.topLeft().x(), rect.topLeft().x() - m_width + rect.width());
+                        m_minOffsetX = - m_width + geometry.width() - left;
-                        m_minOffsetY = 0;
+                        m_minOffsetY = -top;
-                        m_maxOffsetX = 0;
+                        m_maxOffsetX = - right;
-                        m_maxOffsetY = m_height - rect.height();
+                        m_maxOffsetY = m_height - geometry.height() - bottom;
                     }
                     break;
                     default:
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
-                if(which!=Qt::PreferredSize) return QSizeF(-1,-1);
                 if(constraint.isValid()) {
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         size = size.expandedTo(marker->effectiveSizeHint(which));
                     }
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker.cpp +27 -10

                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
-                m_margin(2),
+                m_margin(4),
                 m_space(4)
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
             void LegendMarker::setLabel(const QString label)
             {
-                m_textItem->setText(label);
+                m_text = label;
+                updateGeometry();
             }
             QString LegendMarker::label() const
             {
-                return m_textItem->text();
+                return m_text;
             }
             QRectF LegendMarker::boundingRect() const
             void LegendMarker::setGeometry(const QRectF& rect)
             {
+                QFontMetrics fn (font());
+                int width = rect.width();
+                qreal x = m_margin + m_markerRect.width() +  m_space + m_margin;
+                qreal y = qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin);
+                if (fn.boundingRect(m_text).width() + x > width)
+                {
+                    QString string = m_text + "...";
+                    while(fn.boundingRect(string).width() + x > width && string.length() > 3)
+                        string.remove(string.length() - 4, 1);
+                    m_textItem->setText(string);
+                }
+                else
+                    m_textItem->setText(m_text);
                 const QRectF& textRect = m_textItem->boundingRect();
-                m_textItem->setPos(m_markerRect.width() + m_space + m_margin,rect.height()/2 - textRect.height()/2);
+                m_textItem->setPos(x-m_margin,y/2 - textRect.height()/2);
                 m_rectItem->setRect(m_markerRect);
-                m_rectItem->setPos(m_margin,rect.height()/2 - m_markerRect.height()/2);
+                m_rectItem->setPos(m_margin,y/2  - m_markerRect.height()/2);
                 prepareGeometryChange();
-                m_boundingRect = rect;
+                m_boundingRect = QRectF(0,0,x+textRect.width()+m_margin,y);
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                   switch (which) {
                     case Qt::MinimumSize:
-                        sh = QSizeF(fn.boundingRect("...").width(),fn.height());
+                        sh = QSizeF(fn.boundingRect("...").width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     case Qt::PreferredSize:
-                        sh = QSizeF(fn.boundingRect(m_textItem->text()).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
+                        sh = QSizeF(fn.boundingRect(m_text).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     default:
                       break;
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
-                qDebug()<<"Not implemented"; //TODO: selected signal removed for now
+                //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

src/legend/legendmarker_p.h +1 0

                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;
                 qreal m_space;
+                QString m_text;
             };

src/qchart.cpp +5 -5

             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
             */
-            void QChart::setMinimumMargins(const QMargins& margins)
+            void QChart::setMargins(const QMargins& margins)
             {
-                d_ptr->m_presenter->setMinimumMargins(margins);
+                d_ptr->m_presenter->setMargins(margins);
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
-            QMargins QChart::minimumMargins() const
+            QMargins QChart::margins() const
             {
-                return d_ptr->m_presenter->minimumMargins();
+                return d_ptr->m_presenter->margins();
             }
             /*!
              */
             QRectF QChart::plotArea() const
             {
-                return d_ptr->m_presenter->geometry();
+                return d_ptr->m_presenter->chartsGeometry();
             }
             ///*!

src/qchart.h +3 -3

                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible)
                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
-                Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
+                Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
                 QLegend* legend() const;
-                void setMinimumMargins(const QMargins& margins);
+                void setMargins(const QMargins& margins);
-                QMargins minimumMargins() const;
+                QMargins margins() const;
                 QRectF plotArea() const;

src/src.pro +4 -3

                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
                 $$PWD/scroller.cpp \
-                $$PWD/chartlayout.cpp
+                $$PWD/chartlayout.cpp \
+                $$PWD/charttitle.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
-                $$PWD/chartlayout_p.h
+                $$PWD/chartlayout_p.h \
+                $$PWD/charttitle_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \

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