|
|
/****************************************************************************
|
|
|
**
|
|
|
** 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"
|
|
|
|
|
|
QTCOMMERCIALCHART_BEGIN_NAMESPACE
|
|
|
|
|
|
static const qreal golden_ratio = 0.25;
|
|
|
|
|
|
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();
|
|
|
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);
|
|
|
}
|
|
|
|
|
|
calculateChartGeometry(contentGeometry,axes);
|
|
|
|
|
|
//TODO remove me
|
|
|
#ifdef SHOW_LAYOUT
|
|
|
LayoutDebuger* debuger = LayoutDebuger::instance();
|
|
|
debuger->reset();
|
|
|
debuger->setPen(QPen(Qt::red));
|
|
|
debuger->add(backgroundGeometry,m_presenter->rootItem());
|
|
|
debuger->add(titleGeometry,m_presenter->rootItem());
|
|
|
debuger->add(legendGeometry ,m_presenter->rootItem());
|
|
|
debuger->add(axisGeometry ,m_presenter->rootItem());
|
|
|
debuger->add(geometry,m_presenter->rootItem());
|
|
|
foreach(LegendMarker* marker,legend->d_ptr->markers()){
|
|
|
debuger->add(marker->mapRectToScene(marker->boundingRect()),m_presenter->rootItem());
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
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::calculateChartGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const
|
|
|
{
|
|
|
|
|
|
QSizeF vertical(0,0);
|
|
|
QSizeF horizontal(0,0);
|
|
|
|
|
|
int topAxisCount = 0;
|
|
|
int bottomAxisCount = 0;
|
|
|
int leftAxisCount = 0;
|
|
|
int rightAxisCount = 0;
|
|
|
|
|
|
// check axis size
|
|
|
foreach(ChartAxis* axis , axes) {
|
|
|
if(axis->orientation()==Qt::Vertical && axis->isVisible()) {
|
|
|
// vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
|
|
|
if (axis->alternativePlacement())
|
|
|
rightAxisCount++;
|
|
|
else
|
|
|
leftAxisCount++;
|
|
|
}
|
|
|
else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
|
|
|
// horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
|
|
|
if (axis->alternativePlacement())
|
|
|
topAxisCount++;
|
|
|
else
|
|
|
bottomAxisCount++;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
qreal width = qMin(vertical.width(),geometry.width() * golden_ratio);
|
|
|
|
|
|
QRectF rect = geometry.adjusted(width,vertical.height()/2,-horizontal.width()/2,-horizontal.height());
|
|
|
|
|
|
// axis area width
|
|
|
// TODO: replase with dynamic size code
|
|
|
int axisWidth = 35;
|
|
|
|
|
|
// get the final size of the plot rect
|
|
|
rect.adjust(leftAxisCount * axisWidth, topAxisCount * axisWidth, -rightAxisCount * axisWidth, -bottomAxisCount * axisWidth);
|
|
|
m_presenter->setChartsGeometry(rect);
|
|
|
|
|
|
leftAxisCount = 0;
|
|
|
rightAxisCount = 0;
|
|
|
bottomAxisCount = 0;
|
|
|
topAxisCount = 0;
|
|
|
|
|
|
// adjust the axes internal and external rects
|
|
|
foreach(ChartAxis* axis , axes) {
|
|
|
if(axis->orientation()==Qt::Vertical) {
|
|
|
axis->setInternalRect(rect.adjusted(-leftAxisCount * axisWidth, 0, rightAxisCount * axisWidth, 0));
|
|
|
axis->setGeometry(rect.adjusted(-(leftAxisCount + 1) * axisWidth, 0, (rightAxisCount + 1) * axisWidth, 0));
|
|
|
if (axis->alternativePlacement())
|
|
|
rightAxisCount++;
|
|
|
else
|
|
|
leftAxisCount++;
|
|
|
}
|
|
|
else if(axis->orientation()==Qt::Horizontal) {
|
|
|
axis->setInternalRect(rect.adjusted(0, -topAxisCount * axisWidth, 0, bottomAxisCount * axisWidth));
|
|
|
axis->setGeometry(rect.adjusted(0, -(topAxisCount + 1) * axisWidth, 0, (bottomAxisCount + 1) * axisWidth));
|
|
|
if (axis->alternativePlacement())
|
|
|
topAxisCount++;
|
|
|
else
|
|
|
bottomAxisCount++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return rect;
|
|
|
}
|
|
|
|
|
|
QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const
|
|
|
{
|
|
|
QSizeF vertical(0,0);
|
|
|
QSizeF horizontal(0,0);
|
|
|
|
|
|
// check axis size
|
|
|
foreach(ChartAxis* axis , axes) {
|
|
|
if(axis->orientation()==Qt::Vertical && axis->isVisible()){
|
|
|
vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
|
|
|
}else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
|
|
|
horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
|
|
|
}
|
|
|
}
|
|
|
return minimum.adjusted(0,0,horizontal.width()+vertical.width(),horizontal.height() + vertical.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::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(),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();
|
|
|
}else
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
void ChartLayout::adjustChartGeometry()
|
|
|
{
|
|
|
setGeometry(geometry());
|
|
|
}
|
|
|
|
|
|
QTCOMMERCIALCHART_END_NAMESPACE
|
|
|
|
