HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2148:b2d455450b59

Adds consider title boundary for axis label wrapping

Michal Klocek -

r2148:b2d455450b59

parent child

Context file:

r2148:b2d455450b59

Collapse all files

src/axis/horizontalaxis.cpp +27 -28

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

src/axis/verticalaxis.cpp +33 -30

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "verticalaxis_p.h"
             #include "qabstractaxis.h"
             #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartAxis(axis, presenter, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 QGraphicsSimpleTextItem* title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 //arrow position
                 if (alignment()==Qt::AlignLeft)
                     arrowItem->setLine( axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if(alignment()==Qt::AlignRight)
                     arrowItem->setLine( axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
                 QFontMetrics fn(font());
+                //title
+                if (!titleText().isNull()) {
+                    QFontMetrics fn(title->font());
+                    int size(0);
+                    size = gridRect.height();
+                    QString titleText = this->titleText();
+                    if (fn.boundingRect(titleText).width() > size) {
+                        QString string = titleText + "...";
+                        while (fn.boundingRect(string).width() > size && string.length() > 3)
+                        string.remove(string.length() - 4, 1);
+                        title->setText(string);
+                    }
+                    else {
+                        title->setText(titleText);
+                    }
+                    QPointF center = gridRect.center() - title->boundingRect().center();
+                    if (alignment() == Qt::AlignLeft) {
+                        title->setPos(axisRect.left() - title->boundingRect().width()/2 + title->boundingRect().height()/2 , center.y());
+                    }
+                    else if (alignment() == Qt::AlignRight) {
+                        title->setPos(axisRect.right()- title->boundingRect().width()/2 - title->boundingRect().height()/2, center.y());
+                    }
+                    title->setTransformOriginPoint(title->boundingRect().center());
+                    title->setRotation(270);
+                }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(gridRect.left() , layout[i], gridRect.right(), layout[i]);
                     //label text wrapping
                     QString text = labelList.at(i);
-                    if (fn.boundingRect(text).width() > axisRect.right() - axisRect.left() - labelPadding()) {
+                    qreal size = axisRect.right() - axisRect.left() - labelPadding() - title->boundingRect().height();
+                    if (fn.boundingRect(text).width() > size) {
                         QString label = text + "...";
-                        while (fn.boundingRect(label).width() > axisRect.right() - axisRect.left() - labelPadding() && label.length() > 3)
+                        while (fn.boundingRect(label).width() > size && label.length() > 3)
                             label.remove(label.length() - 4, 1);
                         labelItem->setText(label);
                     } else {
                         labelItem->setText(text);
                     }
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     //ticks and label position
                     if (alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() - labelPadding() , layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
                     } else if (alignment() == Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() , layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(labelItem->pos().x() , layout[i] + delta - center.y());
                     }
                     //label overlap detection
                     if(labelItem->pos().y() + rect.height() > height ||
                         labelItem->pos().y() + rect.height()/2 > gridRect.bottom() ||
                         labelItem->pos().y() + rect.height()/2 < gridRect.top()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(gridRect.left(), layout[i], gridRect.width(), layout[i - 1] - layout[i]);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal y = gridItem->line().p1().y();
                     if ((y < gridRect.top() || y > gridRect.bottom()))
                     {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     }else{
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
-                //title
-                if (!titleText().isNull()) {
-                    QFontMetrics fn(title->font());
-                    int size(0);
-                    size = gridRect.height();
-                    QString titleText = this->titleText();
-                    if (fn.boundingRect(titleText).width() > size) {
-                        QString string = titleText + "...";
-                        while (fn.boundingRect(string).width() > size && string.length() > 3)
-                            string.remove(string.length() - 4, 1);
-                        title->setText(string);
-                    } else {
-                        title->setText(titleText);
-                    QPointF center = gridRect.center() - title->boundingRect().center();
-                    if (alignment() == Qt::AlignLeft) {
-                        title->setPos(axisRect.left() - title->boundingRect().width()/2 + title->boundingRect().height()/2 , center.y());
-                    }else if (alignment() == Qt::AlignRight) {
-                        title->setPos(axisRect.right()- title->boundingRect().width()/2 - title->boundingRect().height()/2, center.y());
-                    title->setTransformOriginPoint(title->boundingRect().center());
-                    title->setRotation(270);
             }
             QSizeF VerticalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QFontMetrics fn(titleFont());
                 QSizeF sh;
                 if (titleText().isNull())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
                         sh = QSizeF(fn.height(), fn.boundingRect("...").width());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
                         sh = QSizeF(fn.height(), fn.boundingRect(axis()->title()).width());
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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

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