##// END OF EJS Templates
Fixed integrated build on OSX
Fixed integrated build on OSX

File last commit:

r716:e7d88adcf7ee
r721:a5d0004908a0
Show More
qlegend.cpp
661 lines | 20.9 KiB | text/x-c | CppLexer
#include "qchartglobal.h"
#include "qlegend.h"
#include "qseries.h"
#include "legendmarker_p.h"
#include "legendscrollbutton_p.h"
#include "qxyseries.h"
#include "qlineseries.h"
#include "qareaseries.h"
#include "qscatterseries.h"
#include "qsplineseries.h"
#include "qbarseries.h"
#include "qstackedbarseries.h"
#include "qpercentbarseries.h"
#include "qbarset.h"
#include "qpieseries.h"
#include "qpieslice.h"
#include "chartpresenter_p.h"
#include <QPainter>
#include <QPen>
#include <QGraphicsSceneEvent>
QTCOMMERCIALCHART_BEGIN_NAMESPACE
QLegend::QLegend(QGraphicsItem *parent)
: QGraphicsObject(parent)
,mPos(0,0)
,mSize(0,0)
,mMinimumSize(50,20) // TODO: magic numbers
,mMaximumSize(150,100)
,m_brush(Qt::darkGray) // TODO: from theme?
,mPreferredLayout(QLegend::PreferredLayoutTop)
,mFirstMarker(0)
,mMargin(5)
{
// setVisible(false);
mScrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
mScrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
mScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
mScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
connect(mScrollButtonLeft,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
connect(mScrollButtonRight,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
connect(mScrollButtonUp,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
connect(mScrollButtonDown,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
setZValue(ChartPresenter::LegendZValue);
}
void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option)
Q_UNUSED(widget)
painter->setOpacity(0.8);
painter->setPen(m_pen);
painter->setBrush(m_brush);
painter->drawRect(boundingRect());
}
QRectF QLegend::boundingRect() const
{
return QRectF(mPos,mSize);
}
void QLegend::setBrush(const QBrush& brush)
{
if(m_brush!=brush){
m_brush = brush;
update();
}
}
QBrush QLegend::brush() const
{
return m_brush;
}
void QLegend::setPen(const QPen& pen)
{
if(m_pen!=pen){
m_pen = pen;
update();
}
}
QPen QLegend::pen() const
{
return m_pen;
}
void QLegend::setPreferredLayout(QLegend::PreferredLayout preferred)
{
mPreferredLayout = preferred;
updateLayout();
}
QLegend::PreferredLayout QLegend::preferredLayout() const
{
return mPreferredLayout;
}
QSizeF QLegend::maximumSize() const
{
return mMaximumSize;
}
void QLegend::setMaximumSize(const QSizeF size)
{
mMaximumSize = size;
updateLayout();
}
void QLegend::setSize(const QSizeF size)
{
mSize = size;
if (mSize.width() > mMaximumSize.width()) {
mSize.setWidth(mMaximumSize.width());
}
if (mSize.height() > mMaximumSize.height()) {
mSize.setHeight(mMaximumSize.height());
}
}
void QLegend::setPos(const QPointF &pos)
{
mPos = pos;
updateLayout();
}
void QLegend::handleSeriesAdded(QSeries* series, Domain* domain)
{
Q_UNUSED(domain)
createMarkers(series);
connectSeries(series);
updateLayout();
}
void QLegend::handleSeriesRemoved(QSeries* series)
{
disconnectSeries(series);
if (series->type() == QSeries::SeriesTypeArea)
{
// This is special case. Area series has upper and lower series, which each have markers
QAreaSeries* s = static_cast<QAreaSeries*> (series);
deleteMarkers(s->upperSeries());
deleteMarkers(s->lowerSeries());
} else {
deleteMarkers(series);
}
updateLayout();
}
void QLegend::handleAdded(QList<QPieSlice*> slices)
{
QPieSeries* series = static_cast<QPieSeries*> (sender());
foreach(QPieSlice* s, slices) {
LegendMarker* marker = new LegendMarker(series,s,this);
marker->setName(s->label());
marker->setBrush(s->sliceBrush());
connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
connect(s,SIGNAL(changed()),marker,SLOT(changed()));
connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
mMarkers.append(marker);
childItems().append(marker);
}
updateLayout();
}
void QLegend::handleRemoved(QList<QPieSlice *> slices)
{
Q_UNUSED(slices)
// Propably no need to listen for this, since removed slices are deleted and we listen destroyed signal
// qDebug() << "QLegend::handleRemoved(QList<QPieSlice*> slices) count:" << slices.count();
}
void QLegend::handleMarkerDestroyed()
{
// TODO: what if more than one markers are destroyed and we update layout after first one?
LegendMarker* m = static_cast<LegendMarker*> (sender());
mMarkers.removeOne(m);
updateLayout();
}
void QLegend::handleScrollButtonClicked(QGraphicsSceneMouseEvent *event)
{
Q_UNUSED(event); // Maybe later somethin happens with right click...
// TODO: detect sender object. scroll to appropiate direction.
LegendScrollButton* scrollButton = static_cast<LegendScrollButton*> (sender());
Q_ASSERT(scrollButton);
switch (scrollButton->id()) {
case LegendScrollButton::ScrollButtonIdLeft:
case LegendScrollButton::ScrollButtonIdUp: {
// Lower limit is same in these cases
mFirstMarker--;
checkMarkerBounds();
break;
}
case LegendScrollButton::ScrollButtonIdRight:
case LegendScrollButton::ScrollButtonIdDown: {
mFirstMarker++;
checkMarkerBounds();
break;
}
default: {
break;
}
}
updateLayout();
}
void QLegend::connectSeries(QSeries *series)
{
// Connect relevant signals from series
switch (series->type())
{
case QSeries::SeriesTypeLine: {
// QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
break;
}
case QSeries::SeriesTypeArea: {
// QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
break;
}
case QSeries::SeriesTypeBar: {
// QBarSeries* barSeries = static_cast<QBarSeries*>(series);
break;
}
case QSeries::SeriesTypeStackedBar: {
// QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
break;
}
case QSeries::SeriesTypePercentBar: {
// QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
break;
}
case QSeries::SeriesTypeScatter: {
// QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
break;
}
case QSeries::SeriesTypePie: {
QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
// connect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
break;
}
case QSeries::SeriesTypeSpline: {
// QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
break;
}
default: {
qDebug()<< "QLegend::connectSeries" << series->type() << "not implemented.";
break;
}
}
}
void QLegend::disconnectSeries(QSeries *series)
{
// Connect relevant signals from series
switch (series->type())
{
case QSeries::SeriesTypeLine: {
// QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
break;
}
case QSeries::SeriesTypeArea: {
// QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
break;
}
case QSeries::SeriesTypeBar: {
// QBarSeries* barSeries = static_cast<QBarSeries*>(series);
break;
}
case QSeries::SeriesTypeStackedBar: {
// QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
break;
}
case QSeries::SeriesTypePercentBar: {
// QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
break;
}
case QSeries::SeriesTypeScatter: {
// QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
break;
}
case QSeries::SeriesTypePie: {
QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
disconnect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
// disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
break;
}
case QSeries::SeriesTypeSpline: {
// QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
break;
}
default: {
qDebug()<< "QLegend::disconnectSeries" << series->type() << "not implemented.";
break;
}
}
}
void QLegend::createMarkers(QSeries *series)
{
switch (series->type())
{
case QSeries::SeriesTypeLine: {
QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
appendMarkers(lineSeries);
break;
}
case QSeries::SeriesTypeArea: {
QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
appendMarkers(areaSeries->upperSeries());
if(areaSeries->lowerSeries())
appendMarkers(areaSeries->lowerSeries());
break;
}
case QSeries::SeriesTypeBar: {
QBarSeries* barSeries = static_cast<QBarSeries*>(series);
appendMarkers(barSeries);
break;
}
case QSeries::SeriesTypeStackedBar: {
QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
appendMarkers(stackedBarSeries);
break;
}
case QSeries::SeriesTypePercentBar: {
QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
appendMarkers(percentBarSeries);
break;
}
case QSeries::SeriesTypeScatter: {
QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
appendMarkers(scatterSeries);
break;
}
case QSeries::SeriesTypePie: {
QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
appendMarkers(pieSeries);
break;
}
case QSeries::SeriesTypeSpline: {
QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
appendMarkers(splineSeries);
break;
}
default: {
qDebug()<< "QLegend::createMarkers" << series->type() << "not implemented.";
break;
}
}
}
void QLegend::appendMarkers(QXYSeries* series)
{
LegendMarker* marker = new LegendMarker(series,this);
marker->setName(series->name());
marker->setBrush(series->brush());
connect(marker,SIGNAL(clicked(QSeries*,Qt::MouseButton)),this,SIGNAL(clicked(QSeries*,Qt::MouseButton)));
connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
mMarkers.append(marker);
childItems().append(marker);
}
void QLegend::appendMarkers(QBarSeries *series)
{
foreach(QBarSet* s, series->barSets()) {
LegendMarker* marker = new LegendMarker(series,s,this);
marker->setName(s->name());
marker->setBrush(s->brush());
connect(marker,SIGNAL(clicked(QBarSet*,Qt::MouseButton)),this,SIGNAL(clicked(QBarSet*,Qt::MouseButton)));
connect(s,SIGNAL(valueChanged()),marker,SLOT(changed()));
connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
mMarkers.append(marker);
childItems().append(marker);
}
}
void QLegend::appendMarkers(QPieSeries *series)
{
foreach(QPieSlice* s, series->slices()) {
LegendMarker* marker = new LegendMarker(series,s,this);
marker->setName(s->label());
marker->setBrush(s->sliceBrush());
connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
connect(s,SIGNAL(changed()),marker,SLOT(changed()));
connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
mMarkers.append(marker);
childItems().append(marker);
}
}
void QLegend::deleteMarkers(QSeries *series)
{
// Search all markers that belong to given series and delete them.
foreach (LegendMarker *m, mMarkers) {
if (m->series() == series) {
mMarkers.removeOne(m);
delete m;
}
}
}
void QLegend::updateLayout()
{
// Calculate layout for markers and text
if (mMarkers.count() <= 0) {
// Nothing to do
return;
}
checkMarkerBounds();
// Find out widest item.
QSizeF markerMaxSize = maximumMarkerSize();
// Use max height as scroll button size
rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
qreal totalWidth = 0;
qreal totalHeight = 0;
switch (mPreferredLayout)
{
// Both cases organise items horizontally
case QLegend::PreferredLayoutBottom:
case QLegend::PreferredLayoutTop: {
qreal xStep = markerMaxSize.width();
qreal x = mPos.x() + mMargin;
qreal y = mPos.y() + mMargin;
int column = 0;
int maxColumns = 1;
qreal scrollButtonPadding = 0;
// Set correct visibility for scroll scrollbuttons
if (scrollButtonsVisible()) {
mScrollButtonLeft->setVisible(true);
mScrollButtonRight->setVisible(true);
totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2; // scrollbuttons visible, so add their width to total width
x += mScrollButtonLeft->boundingRect().width() + mMargin; // start position changes by scrollbutton width
scrollButtonPadding = mScrollButtonLeft->boundingRect().width();
} else {
mScrollButtonLeft->setVisible(false);
mScrollButtonRight->setVisible(false);
}
mScrollButtonUp->setVisible(false);
mScrollButtonDown->setVisible(false);
for (int i=0; i<mMarkers.count(); i++) {
LegendMarker* m = mMarkers.at(i);
if (i<mFirstMarker) {
// Markers before first are not visible.
m->setVisible(false);
} else {
if ((x + xStep + scrollButtonPadding) > (mPos.x() + mMaximumSize.width())) {
// This marker would go outside legend rect.
m->setVisible(false);
} else {
// This marker is ok
m->setVisible(true);
m->setPos(x,y);
x += xStep;
column++;
}
}
maxColumns = column;
}
mScrollButtonLeft->setPos(mPos.x() + mMargin, y);
mScrollButtonRight->setPos(x+mMargin,y);
totalWidth += maxColumns * markerMaxSize.width() + mMargin * 2;
totalHeight = markerMaxSize.height() + mMargin * 2;
break;
}
// Both cases organize items vertically
case QLegend::PreferredLayoutLeft:
case QLegend::PreferredLayoutRight: {
qreal yStep = markerMaxSize.height();
qreal x = mPos.x() + mMargin;
qreal y = mPos.y() + mMargin;
int row = 1;
int maxRows = 1;
qreal scrollButtonPadding = 0;
// Set correct visibility for scroll scrollbuttons
if (scrollButtonsVisible()) {
mScrollButtonUp->setVisible(true);
mScrollButtonDown->setVisible(true);
totalHeight += (mScrollButtonUp->boundingRect().height() + mMargin) * 2; // scrollbuttons visible, so add their height to total height
y += mScrollButtonUp->boundingRect().height() + mMargin; // start position changes by scrollbutton height
scrollButtonPadding = mScrollButtonUp->boundingRect().height();
} else {
mScrollButtonUp->setVisible(false);
mScrollButtonDown->setVisible(false);
}
mScrollButtonLeft->setVisible(false);
mScrollButtonRight->setVisible(false);
for (int i=0; i<mMarkers.count(); i++) {
LegendMarker* m = mMarkers.at(i);
if (i<mFirstMarker) {
// Markers before first are not visible.
m->setVisible(false);
} else {
if ((y + yStep + scrollButtonPadding) > (mPos.y() + mMaximumSize.height())) {
// This marker would go outside legend rect.
m->setVisible(false);
} else {
// This marker is ok
m->setVisible(true);
m->setPos(x,y);
y += yStep;
row++;
}
}
maxRows = row;
}
mScrollButtonUp->setPos(mPos.x() + mMargin, mPos.y() + mMargin);
mScrollButtonDown->setPos(mPos.x() + mMargin, y + mMargin);
totalWidth += markerMaxSize.width() + mMargin * 2;
totalHeight = maxRows * markerMaxSize.height() + mMargin * 4 + scrollButtonPadding; // TODO: check this
/*
qreal yStep = markerMaxSize.height();
qreal x = mPos.x() + mMargin;
qreal y = mPos.y() + mMargin;
int row = 0;
int maxRows = 1;
int maxColumns = 1;
for (int i=0; i<mMarkers.count(); i++) {
LegendMarker* m = mMarkers.at(i);
if (i<mFirstMarker) {
// Markers before first are not visible.
m->setVisible(false);
} else {
if ((y + markerMaxSize.height() + mMargin*2) > (mPos.y() + mMaximumSize.height())) {
// This marker would go outside legend rect.
m->setVisible(false);
} else {
// This marker is ok
m->setVisible(true);
maxRows = row;
m->setPos(x,y);
y += yStep;
row++;
}
}
maxRows = row;
}
totalWidth = maxColumns * markerMaxSize.width() + mMargin * 2;
totalHeight = maxRows * markerMaxSize.height() + mMargin * 2;
*/
break;
}
default: {
break;
}
}
mSize.setWidth(totalWidth);
mSize.setHeight(totalHeight);
update();
}
void QLegend::rescaleScrollButtons(const QSize &size)
{
QPolygonF left;
left << QPointF(size.width(),0) << QPointF(0,size.height()/2) << QPointF(size.width(),size.height());
QPolygonF right;
right << QPointF(0,0) << QPointF(size.width(),size.height()/2) << QPointF(0,size.height());
QPolygonF up;
up << QPointF(0,size.height()) << QPointF(size.width()/2,0) << QPointF(size.width(),size.height());
QPolygonF down;
down << QPointF(0,0) << QPointF(size.width()/2,size.height()) << QPointF(size.width(),0);
mScrollButtonLeft->setPolygon(left);
mScrollButtonRight->setPolygon(right);
mScrollButtonUp->setPolygon(up);
mScrollButtonDown->setPolygon(down);
}
QSizeF QLegend::maximumMarkerSize()
{
QSizeF max(0,0);
foreach (LegendMarker* m, mMarkers) {
if (m->boundingRect().width() > max.width()) {
max.setWidth(m->boundingRect().width());
}
if (m->boundingRect().height() > max.height()) {
max.setHeight(m->boundingRect().height());
}
}
return max;
}
void QLegend::checkMarkerBounds()
{
if ((mPreferredLayout == QLegend::PreferredLayoutLeft) || (mPreferredLayout == QLegend::PreferredLayoutRight)) {
// Bounds limited by height
int max;
if (scrollButtonsVisible()) {
max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin*2) / maximumMarkerSize().height();
} else {
max = mMaximumSize.height() / maximumMarkerSize().height();
}
if (mFirstMarker > mMarkers.count() - max) {
mFirstMarker = mMarkers.count() - max;
}
} else {
// Bounds limited by width
int max;
if (scrollButtonsVisible()) {
max = (mMaximumSize.width() - mScrollButtonLeft->boundingRect().width() * 2 - mMargin*2) / maximumMarkerSize().width();
} else {
max = mMaximumSize.width() / maximumMarkerSize().width();
}
if (mFirstMarker > mMarkers.count() - max) {
mFirstMarker = mMarkers.count() - max;
}
}
if (mFirstMarker < 0) {
mFirstMarker = 0;
}
}
bool QLegend::scrollButtonsVisible()
{
// Just a helper to clarify, what the magic below means :)
if ((mPreferredLayout == QLegend::PreferredLayoutTop) || (mPreferredLayout == QLegend::PreferredLayoutBottom)) {
return (maximumMarkerSize().width() * mMarkers.count() + mMargin * 3 > mMaximumSize.width());
}
return (maximumMarkerSize().height() * mMarkers.count() + mMargin * 3 > mMaximumSize.height());
}
#include "moc_qlegend.cpp"
QTCOMMERCIALCHART_END_NAMESPACE