HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1837:21f33dedea6d

Bugfixes for layout...

Michal Klocek -

r1837:21f33dedea6d

parent child

Context file:

r1837:21f33dedea6d

Collapse all files

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

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include <QDebug>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisX::~ChartCategoriesAxisX()
             {
             }
             QVector<qreal> ChartCategoriesAxisX::calculateLayout() const
             {
                 int count = m_categoriesAxis->d_ptr->count();
                 Q_ASSERT(count>=1);
                 QVector<qreal> points;
                 points.resize(count+2);
                 const qreal delta = m_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;
                 }
                 else {
                     offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta);
                 }
                 points[0] = m_rect.left();
                 points[count+1] = m_rect.right();
                 for (int i = 0; i < count; ++i) {
                     qreal x = offset + i * delta + m_rect.left();
                     points[i+1] = x;
                 }
                 return points;
             }
             QStringList ChartCategoriesAxisX::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
                 qreal d = (m_max - m_min)/m_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));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
                     else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartCategoriesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 const qreal delta = m_rect.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());
                 qreal width = m_rect.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());
                     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());
                     if(i==0){
                         labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }else{
                         labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }
                     if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()>m_rect.right()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         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());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
             }
             void ChartCategoriesAxisX::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
                     if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartbarcategoryaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
             #include <qmath.h>
+            #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisY::~ChartCategoriesAxisY()
             {
             }
             QVector<qreal> ChartCategoriesAxisY::calculateLayout() const
             {
                 int count = m_categoriesAxis->d_ptr->count();
                 Q_ASSERT(count>=1);
                 QVector<qreal> points;
                 points.resize(count+2);
                 const qreal delta = m_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;
                 }
                 else {
                     offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta);
                 }
                 points[0] = m_rect.bottom();
                 points[count+1] = m_rect.top();
                 for (int i = 0; i < count; ++i) {
                     int y = m_rect.bottom() - i * delta - offset;
                     points[i+1] = y;
                 }
                 return points;
             }
             QStringList ChartCategoriesAxisY::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
                 qreal d = (m_max - m_min)/m_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));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
                     else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartCategoriesAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 const qreal delta = m_rect.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());
                 qreal height = m_rect.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]);
                     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());
                     if(i==0) {
                        labelItem->setPos(m_rect.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());
                     }
                     if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_rect.top()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
-                    m_minWidth+=rect.width();
+                    m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
-                    m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
+                    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]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartCategoriesAxisY::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
                     if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) {
                         updateGeometry();
                     }
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartcategoryaxisx_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisX::ChartCategoryAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartCategoryAxisX::~ChartCategoryAxisX()
             {
             }
             QVector<qreal> ChartCategoryAxisX::calculateLayout() const
             {
                 QCategoryAxis *axis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 int tickCount = axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.width() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int x = axis->categoryStart(axis->categoriesLabels().at(i)) * scale + m_rect.left();
                         points[i] = x;
                     } else {
                         int x = axis->categoryEnd(axis->categoriesLabels().at(i - 1))  * scale + m_rect.left();
                         points[i] = x;
                     }
                 return points;
             }
             void ChartCategoryAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->categoriesLabels();
                 //    createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.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());
                     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 < ticksList.count())
                         labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), m_rect.bottom() + label_padding);
                     else
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                     if(labelItem->pos().x() > m_rect.width() + m_rect.left() - rect.width() / 2){
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     m_minWidth += rect.width();
-                    m_minHeight = qMax(rect.height(), m_minHeight);
+                    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());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i], m_rect.bottom() + 5);
                 }
             }
             void ChartCategoryAxisX::handleAxisUpdated()
             {
                 updateGeometry();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisy.cpp +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartcategoryaxisy_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartCategoryAxisY::~ChartCategoryAxisY()
             {
             }
             QVector<qreal> ChartCategoryAxisY::calculateLayout() const
             {
                 QCategoryAxis *axis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 int tickCount = axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.height() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int y = -axis->categoryStart(axis->categoriesLabels().at(i)) * scale + m_rect.bottom();
                         points[i] = y;
                     } else {
                         int y = -axis->categoryEnd(axis->categoriesLabels().at(i - 1))  * scale + m_rect.bottom();
                         points[i] = y;
                     }
                 return points;
             }
             void ChartCategoryAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
-                if(layout.isEmpty()) return;
+                if(layout.isEmpty()) {
+                    return;
+                }
                 QCategoryAxis *intervalAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->categoriesLabels();
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*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());
                 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]);
                     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 < ticksList.count())
                         labelItem->setPos(m_rect.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());
                     if(labelItem->pos().y()+rect.height()>height) {
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     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]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartCategoryAxisY::handleAxisUpdated()
             {
                 updateGeometry();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : ChartElement(presenter),
                 m_chartAxis(axis),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_animation(0),
                 m_minWidth(0),
                 m_minHeight(0)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation* animation)
             {
                 m_animation=animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector=layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->children().size() == 0)
                 m_arrow->addToGroup(new AxisItem(this,presenter()->rootItem()));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     m_labels->addToGroup(new QGraphicsSimpleTextItem(presenter()->rootItem()));
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
                     deleteItems(diff);
                 }
                 else if (diff<0) {
                     createItems(-diff);
                 }
                 if(diff<0) handleAxisUpdated();
                 if (m_animation) {
                       switch(presenter()->state()){
                           case ChartPresenter::ZoomInState:
                               m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ZoomOutState:
                               m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ScrollUpState:
                           case ChartPresenter::ScrollLeftState:
                               m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                               break;
                           case ChartPresenter::ScrollDownState:
                           case ChartPresenter::ScrollRightState:
                               m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                               break;
                           case ChartPresenter::ShowState:
                               m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                               break;
                       }
                       m_animation->setValues(m_layoutVector,layout);
                       presenter()->startAnimation(m_animation);
                 }
                 else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
                 m_font = font;
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_arrow->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain* domain = qobject_cast<Domain*>(sender());
                 qreal min(0);
                 qreal max(0);
                 if(m_chartAxis->orientation()==Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 }
                 else if (m_chartAxis->orientation()==Qt::Vertical)
                 {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max))
                 {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if(isEmpty()) return;
                 bool visible = m_chartAxis->isVisible();
                 setArrowVisibility(visible && m_chartAxis->isArrowVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             qreal ChartAxis::minimumWidth()
             {
                 if(m_minWidth == 0) updateGeometry();
                 return m_minWidth;
             }
             qreal ChartAxis::minimumHeight()
             {
                 if(m_minHeight == 0) updateGeometry();
                 return m_minHeight;
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             void ChartAxis::createNumberLabels(QStringList &labels,qreal min, qreal max, int ticks) const
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 int n = qMax(int(-qFloor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QString::number(value,'f',n);
                 }
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout.cpp +15 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlayout_p.h"
             #include "chartpresenter_p.h"
+            #include "qlegend_p.h"
             #include "chartaxis_p.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLayout::ChartLayout(ChartPresenter* presenter):
             m_presenter(presenter),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
-            m_chartMargins(QPointF(m_marginBig,m_marginBig),QPointF(m_marginBig,m_marginBig))
+            m_chartMargins(QPointF(m_marginBig,m_marginBig),QPointF(m_marginBig,m_marginBig)),
+            m_intialized(false)
             {
             }
             ChartLayout::~ChartLayout()
             {
             }
             void ChartLayout::setGeometry(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 QGraphicsLayout::setGeometry(rect);
+                if(!m_intialized){
+                    m_presenter->setGeometry(rect);
+                    m_intialized=true;
+                }
                 // check title size
                 QSize titleSize = QSize(0,0);
                 if (m_presenter->titleItem()) {
                     titleSize= m_presenter->titleItem()->boundingRect().size().toSize();
                 }
                 qreal axisHeight = 0;
                 qreal axisWidth = 0;
                 // check axis size
                 foreach (ChartAxis* axis,m_presenter->axisItems()){
                     if(axis->axisType() ==  ChartAxis::X_AXIS)
                     axisHeight = qMax(axis->minimumHeight(),axisHeight);
                     else
                     axisWidth = qMax(axis->minimumWidth(),axisWidth);
                 }
                 QLegend* legend = m_presenter->legend();
+                Q_ASSERT(legend);
                 qreal titlePadding = m_chartMargins.top()/2;
                 QRectF chartMargins = m_chartMargins;
                 // recalculate legend position
-                if (legend != 0 && legend->isVisible() && legend->isAttachedToChart()) {
+                if ((legend->isAttachedToChart() && legend->isVisible())) {
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case Qt::AlignTop: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
                         int topMargin = 2*m_marginTiny + titleSize.height() + legendSize.height() + m_marginTiny;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),topMargin),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny)),QPoint(chartMargins.right(),rect.height()-topMargin + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case Qt::AlignBottom: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
-                        int bottomMargin = m_marginTiny + m_marginSmall +  legendSize.height() + m_marginTiny + axisHeight;
+                        int bottomMargin = m_marginTiny + legendSize.height() + m_marginTiny + axisHeight;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomMargin));
                         m_legendMargins = QRect(QPoint(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight),QPoint(chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignLeft: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
-                        int leftPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny + axisWidth;
+                        int leftPadding = m_marginTiny + legendSize.width() + m_marginTiny + axisWidth;
                         chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,chartMargins.top()),QPoint(rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom()));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignRight: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
-                        int rightPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny;
+                        int rightPadding = m_marginTiny + legendSize.width() + m_marginTiny;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,chartMargins.bottom()));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                     legend->setGeometry(rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 }
                 // recalculate title position
                 if (m_presenter->titleItem()) {
                     QPointF center = rect.center() - m_presenter->titleItem()->boundingRect().center();
                     m_presenter->titleItem()->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_presenter->backgroundItem()) {
                     m_presenter->backgroundItem()->setRect(rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = rect.adjusted(chartMargins.left(),chartMargins.top(),-chartMargins.right(),-chartMargins.bottom());
                 if(m_presenter->geometry()!=chartRect && chartRect.isValid()){
                     m_presenter->setGeometry(chartRect);
                 }else if(chartRect.size().isEmpty()){
                     m_presenter->setGeometry(QRect(rect.width()/2,rect.height()/2,1,1));
                 }
             }
             QSizeF ChartLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
             {
                 Q_UNUSED(constraint);
                 if(which == Qt::MinimumSize)
                     return QSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                 else
                     return QSize(-1,-1);
             }
             void ChartLayout::setMarginsMinimum(const QRectF& margins)
             {
                 if(m_chartMargins != margins){
                     m_chartMargins = margins;
                     updateGeometry();
                 }
             }
             QRectF ChartLayout::margins() const
             {
                 return m_chartMargins;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout_p.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CHARTLAYOUT_H_
             #define CHARTLAYOUT_H_
             #include <QGraphicsLayout>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartLayout : public QGraphicsLayout
             {
             public:
                 ChartLayout(ChartPresenter* presenter);
                 virtual ~ChartLayout();
                 void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
                 void setGeometry(const QRectF& rect);
             protected:
                 QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
                 int count() const { return 0; }
                 QGraphicsLayoutItem* itemAt(int) const { return 0; };
                 void removeAt(int){};
             private:
                 ChartPresenter* m_presenter;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
+                bool m_intialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/legend/legendlayout.cpp +4 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "legendmarker_p.h"
             #include "qlegend_p.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendLayout::LegendLayout(QLegend* legend):
             m_legend(legend)
             {
             }
             LegendLayout::~LegendLayout()
             {
             }
             void LegendLayout::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch(m_legend->alignment()) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         scrollHorizontal = true;
                         break;
                     }
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         scrollHorizontal = false;
                         break;
                     }
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_legend->isAttachedToChart()) {
                     scrollHorizontal = !scrollHorizontal;
                 }
                 QRectF boundingRect = geometry();
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if(m_width<=boundingRect.width()) return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_legend->d_ptr->items()->setPos(-m_offsetX,boundingRect.top());
                     }
                 }
                 else {
                     if(m_height<=boundingRect.height()) return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_legend->d_ptr->items()->setPos(boundingRect.left(),-m_offsetY);
                     }
                 }
             }
             QPointF LegendLayout::offset() const
             {
                 return QPointF(m_offsetX,m_offsetY);
             }
             void LegendLayout::setGeometry(const QRectF& rect)
             {
+                m_legend->d_ptr->items()->setVisible(m_legend->isVisible());
-                QGraphicsLayout::setGeometry(rect);
                 if(m_legend->isAttachedToChart()) {
                     setAttachedGeometry(rect);
                 }
                 else {
                     setDettachedGeometry(rect);
                 }
+                QGraphicsLayout::setGeometry(rect);
             }
             void LegendLayout::setAttachedGeometry(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 m_offsetX=0;
                 m_offsetY=0;
                 QSizeF size(0,0);
                 if( m_legend->d_ptr->markers().isEmpty()) return;
                 m_width=0;
                 m_height=0;
                 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->setPos(point.x(),rect.height()/2 - marker->boundingRect().height()/2);
                                 const QRectF& rect = marker->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if(m_width<rect.width()) {
                             m_legend->d_ptr->items()->setPos(rect.width()/2-m_width/2,rect.top());
                         }
                         else {
                             m_legend->d_ptr->items()->setPos(rect.topLeft());
                         }
                         m_height=size.height();
                     }
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         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->setPos(point);
                                 const QRectF& rect = marker->boundingRect();
                                 qreal h = rect.height();
                                 size = size.expandedTo(rect.size());
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if(m_height<rect.height()) {
                             m_legend->d_ptr->items()->setPos(rect.left(),rect.height()/2-m_height/2);
                         }
                         else {
                             m_legend->d_ptr->items()->setPos(rect.topLeft());
                         }
                         m_width=size.width();
                     }
                     break;
                 }
                 m_minOffsetX = 0;
                 m_minOffsetY = 0;
                 m_maxOffsetX = m_width - rect.width();
                 m_maxOffsetY = m_height - rect.height();
             }
             void LegendLayout::setDettachedGeometry(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX=0;
                 m_offsetY=0;
                 QSizeF size(0,0);
                 QList<LegendMarker *> markers = m_legend->d_ptr->markers();
                 if(markers.isEmpty()) return;
                 switch (m_legend->alignment()) {
                     case Qt::AlignTop: {
                         QPointF point = rect.topLeft();
                         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->setPos(point.x(),point.y());
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 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()) {
                                     // Next item would go off rect.
                                     point.setX(rect.topLeft().x());
                                     point.setY(point.y() + h);
                                     if (i+1 < markers.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     case Qt::AlignBottom: {
                         QPointF point = rect.bottomLeft();
                         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)));
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_width = qMax(m_width,w);
                                 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()) {
                                     // Next item would go off rect.
                                     point.setX(rect.bottomLeft().x());
                                     point.setY(point.y() - h);
                                     if (i+1 < markers.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = qMin(rect.topLeft().y(), rect.topLeft().y() - m_height + rect.height());
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = 0;
                     }
                     break;
                     case Qt::AlignLeft: {
                         QPointF point = rect.topLeft();
                         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)));
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height,h);
                                 maxWidth = qMax(maxWidth,w);
                                 marker->setPos(point.x(),point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > rect.topLeft().y() + rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() + maxWidth);
                                     point.setY(rect.topLeft().y());
                                     if (i+1 < markers.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     case Qt::AlignRight: {
                         QPointF point = rect.topRight();
                         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)));
                                 const QRectF& boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height,h);
                                 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()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() - maxWidth);
                                     point.setY(rect.topLeft().y());
                                     if (i+1 < markers.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = qMin(rect.topLeft().x(), rect.topLeft().x() - m_width + rect.width());
                         m_minOffsetY = 0;
                         m_maxOffsetX = 0;
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     default:
                     break;
                 }
             }
             QSizeF LegendLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
             {
                 QSizeF size(0, 0);
                 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 = size.boundedTo(constraint);
                 }
                 else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         width+=marker->effectiveSizeHint(which).width();
                         height=qMax(height,marker->effectiveSizeHint(which).height());
                     }
                     size = QSizeF(qMin(constraint.width(),width), height);
                 }
                 else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         width=qMax(width,marker->effectiveSizeHint(which).width());
                         height+=height,marker->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width,qMin(constraint.height(),height));
                 }
                 else {
                     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/qlegend.cpp +4 -4

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendlayout_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsLayout>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty color Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setFont(d_ptr->m_font);
                     }
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                         // Note: The pen of the marker rectangle could be exposed in the public QLegend API
                         // instead of mapping it from label brush color
                         marker->setPen(brush.color());
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     updateGeometry();
                     if(isAttachedToChart()){
                         d_ptr->m_presenter->layout()->invalidate();
                     }else{
                         layout()->invalidate();
                     }
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
                 d_ptr->m_layout->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
                 d_ptr->m_layout->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
-                QGraphicsWidget::hideEvent(event);
+               d_ptr->m_presenter->layout()->invalidate();
-                d_ptr->m_presenter->layout()->invalidate();
+               QGraphicsWidget::hideEvent(event);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
-                QGraphicsWidget::showEvent(event);
+               d_ptr->m_presenter->layout()->invalidate();
-                d_ptr->m_presenter->layout()->invalidate();
+               QGraphicsWidget::showEvent(event);
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_layout(new LegendLayout(q)),
                 m_chart(chart),
                 m_items(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_labelBrush(QBrush()),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                m_layout->setOffset(x,y);
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                     marker->setVisible(series->isVisible());
                     m_items->addToGroup(marker);
                     m_markers<<marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
                 q_ptr->layout()->activate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 foreach (LegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         delete marker;
                         m_markers.removeAll(marker);
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 foreach (LegendMarker* marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                     }
                 }
                 q_ptr->layout()->invalidate();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <qchartglobal.h>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QAbstractBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelColor(QColor color);
                 QColor labelColor() const;
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
             protected:
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void fontChanged(QFont font);
                 void labelColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
                 friend class LegendLayout;
                 friend class ChartLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_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