HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2196:aa4c8d495212

legend markers example. bugfix to legend scrolling

sauimone -

r2196:aa4c8d495212

parent child

Context file:

r2196:aa4c8d495212

Collapse all files

examples/legendmarkers/legendmarkers.pro created 644 +10 0

@@ -0,0 +1,10
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = legendmarkers
	6	SOURCES += main.cpp \
	7	mainwidget.cpp
	8
	9	HEADERS += \
	10	mainwidget.h

examples/legendmarkers/main.cpp created 644 +35 0

@@ -0,0 +1,35
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "mainwidget.h"
	22
	23	#include <QApplication>
	24	#include <QMainWindow>
	25
	26	int main(int argc, char *argv[])
	27	{
	28	QApplication a(argc, argv);
	29
	30	MainWidget w;
	31	w.resize(720, 480);
	32	w.show();
	33
	34	return a.exec();
	35	}

examples/legendmarkers/mainwidget.cpp created 644 +181 0

@@ -0,0 +1,181
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "mainwidget.h"
	22	#include <QChart>
	23	#include <QChartView>
	24	#include <QPushButton>
	25	#include <QLabel>
	26	#include <QDebug>
	27	#include <QLegend>
	28	#include <QFormLayout>
	29	#include <QLegendMarker>
	30	#include <QLineSeries>
	31	#include <QXYLegendMarker>
	32	#include <qmath.h>
	33
	34	QTCOMMERCIALCHART_USE_NAMESPACE
	35
	36	MainWidget::MainWidget(QWidget *parent) :
	37	QWidget(parent)
	38	{
	39	// Create buttons for ui
	40	m_buttonLayout = new QGridLayout();
	41
	42	QPushButton *addSliceButton = new QPushButton("add series");
	43	connect(addSliceButton, SIGNAL(clicked()), this, SLOT(addSeries()));
	44	m_buttonLayout->addWidget(addSliceButton, 1, 0);
	45
	46	QPushButton *removeSliceButton = new QPushButton("remove series");
	47	connect(removeSliceButton, SIGNAL(clicked()), this, SLOT(removeSeries()));
	48	m_buttonLayout->addWidget(removeSliceButton, 2, 0);
	49
	50	QPushButton *connectButton = new QPushButton("Connect markers");
	51	connect(connectButton, SIGNAL(clicked()), this, SLOT(connectMarkers()));
	52	m_buttonLayout->addWidget(connectButton, 3, 0);
	53
	54	QPushButton *disConnectButton = new QPushButton("Disconnect markers");
	55	connect(disConnectButton, SIGNAL(clicked()), this, SLOT(disconnectMarkers()));
	56	m_buttonLayout->addWidget(disConnectButton, 4, 0);
	57
	58	// Create chart view with the chart
	59	m_chart = new QChart();
	60	m_chartView = new QChartView(m_chart, this);
	61
	62	// Create layout for grid and detached legend
	63	m_mainLayout = new QGridLayout();
	64	m_mainLayout->addLayout(m_buttonLayout, 0, 0);
	65	m_mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
	66	setLayout(m_mainLayout);
	67
	68	// Add few series
	69	addSeries();
	70	addSeries();
	71	addSeries();
	72	addSeries();
	73
	74	// Set the title and show legend
	75	m_chart->setTitle("Legendmarker example");
	76	m_chart->legend()->setVisible(true);
	77	m_chart->legend()->setAlignment(Qt::AlignBottom);
	78
	79	m_chartView->setRenderHint(QPainter::Antialiasing);
	80	}
	81
	82	void MainWidget::addSeries()
	83	{
	84	QLineSeries *series = new QLineSeries();
	85	m_series.append(series);
	86
	87	series->setName(QString("line " + QString::number(m_series.count())));
	88
	89	// Make some sine wave for data
	90	QList<QPointF> data;
	91	int offset = m_chart->series().count();
	92	for (int i = 0; i < 360; i++) {
	93	qreal x = offset * 20 + i;
	94	data.append(QPointF(i, qSin(2.0 * 3.141592 * x / 360.0)));
	95	}
	96
	97	series->append(data);
	98	m_chart->addSeries(series);
	99
	100	if (m_series.count() == 1) {
	101	m_chart->createDefaultAxes();
	102	}
	103	}
	104
	105	void MainWidget::removeSeries()
	106	{
	107	// Remove last series from chart
	108	if (m_series.count() > 0) {
	109	QLineSeries *series = m_series.last();
	110	m_chart->removeSeries(series);
	111	m_series.removeLast();
	112	delete series;
	113	}
	114	}
	115
	116	void MainWidget::connectMarkers()
	117	{
	118	//![1]
	119	// Connect all markers to handler
	120	foreach (QLegendMarker* marker, m_chart->legend()->markers()) {
	121	// Disconnect possible existing connection to avoid multiple connections
	122	QObject::disconnect(marker, SIGNAL(clicked()), this, SLOT(handleMarkerClicked()));
	123	QObject::connect(marker, SIGNAL(clicked()), this, SLOT(handleMarkerClicked()));
	124	}
	125	//![1]
	126	}
	127
	128	void MainWidget::disconnectMarkers()
	129	{
	130	//![2]
	131	foreach (QLegendMarker* marker, m_chart->legend()->markers()) {
	132	QObject::disconnect(marker, SIGNAL(clicked()), this, SLOT(handleMarkerClicked()));
	133	}
	134	//![2]
	135	}
	136
	137	void MainWidget::handleMarkerClicked()
	138	{
	139	//![3]
	140	QLegendMarker* marker = qobject_cast<QLegendMarker*> (sender());
	141	Q_ASSERT(marker);
	142	//![3]
	143
	144
	145	//![4]
	146	switch (marker->type())
	147	//![4]
	148	{
	149	case QLegendMarker::LegendMarkerTypeXY:
	150	{
	151	//![5]
	152	// Toggle visibility of series
	153	marker->series()->setVisible(!marker->series()->isVisible());
	154
	155	// Turn legend marker back to visible, since hiding series also hides the marker
	156	// and we don't want it to happen now.
	157	marker->setVisible(true);
	158	//![5]
	159
	160	//![6]
	161	// Dim the marker, if series is not visible
	162	QXYLegendMarker xymarker = qobject_cast<QXYLegendMarker > (marker);
	163	QColor color = xymarker->labelBrush().color();
	164
	165	if (marker->series()->isVisible()) {
	166	color.setAlphaF(1.0);
	167	} else {
	168	color.setAlphaF(0.5);
	169	}
	170
	171	xymarker->setLabelBrush(QBrush(color));
	172	//![6]
	173	break;
	174	}
	175	default:
	176	{
	177	qDebug() << "Unknown marker type";
	178	break;
	179	}
	180	}
	181	}

examples/legendmarkers/mainwidget.h created 644 +63 0

@@ -0,0 +1,63
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef MAINWIDGET_H
	22	#define MAINWIDGET_H
	23
	24	#include "qchartglobal.h"
	25	#include "qchart.h"
	26	#include "qchartview.h"
	27	#include <QWidget>
	28	#include <QGraphicsWidget>
	29	#include <QGridLayout>
	30	#include <QGraphicsGridLayout>
	31	#include <QDoubleSpinBox>
	32	#include <QGroupBox>
	33	#include <QLineSeries>
	34
	35	QTCOMMERCIALCHART_USE_NAMESPACE
	36
	37	class MainWidget : public QWidget
	38	{
	39	Q_OBJECT
	40	public:
	41	explicit MainWidget(QWidget *parent = 0);
	42
	43	public slots:
	44	void addSeries();
	45	void removeSeries();
	46	void connectMarkers();
	47	void disconnectMarkers();
	48
	49	void handleMarkerClicked();
	50
	51	private:
	52
	53	QChart *m_chart;
	54	QList<QLineSeries *> m_series;
	55
	56	QChartView *m_chartView;
	57	QGridLayout *m_mainLayout;
	58	QGridLayout *m_buttonLayout;
	59	QGridLayout *m_fontLayout;
	60
	61	};
	62
	63	#endif // MAINWIDGET_H

examples/examples.pro +2 -1

             CURRENTLY_BUILDING_COMPONENTS = "examples"
             !include( ../config.pri ) {
                 error( "Couldn't find the config.pri file!" )
             }
             TEMPLATE = subdirs
             SUBDIRS += \
                        areachart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        presenterchart \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
                        modeldata \
                        barchart \
                        legend \
                        barmodelmapper \
                        qmlpiechart \
                        lineandbar \
                        horizontalbarchart \
                        horizontalstackedbarchart \
                        horizontalpercentbarchart \
                        donutbreakdown \
                        scrollchart \
                        temperaturerecords \
                        donutchart \
                        multiaxis \
                        callout \
-                       newlegend
+                       newlegend \
+                       legendmarkers
             !linux-arm*: {
             SUBDIRS += \
                 datetimeaxis
             }

src/legend/legendlayout.cpp +10 -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 "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
             #include "chartlayout_p.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "qlegendmarker.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendLayout::LegendLayout(QLegend *legend)
-                : m_legend(legend)
+                : m_legend(legend),
+                  m_offsetX(0),
+                  m_offsetY(0)
             {
             }
             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();
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 boundingRect.adjust(left, top, -right, -bottom);
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     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::invalidate()
             {
                 QGraphicsLayout::invalidate();
                 if (m_legend->isAttachedToChart())
                     m_legend->d_ptr->m_presenter->layout()->invalidate();
             }
             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);
             }
             void LegendLayout::setAttachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
+                qreal oldOffsetX = m_offsetX;
+                qreal oldOffsetY = m_offsetY;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 QSizeF size(0, 0);
                 if (m_legend->d_ptr->markers().isEmpty()) {
                     return;
                 }
                 m_width = 0;
                 m_height = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 switch(m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom: {
                         QPointF point(0,0);
                         foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
                             LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 item->setGeometry(geometry);
                                 item->setPos(point.x(),geometry.height()/2 - item->boundingRect().height()/2);
                                 const QRectF &rect = item->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if (m_width < geometry.width())
                             m_legend->d_ptr->items()->setPos(geometry.width() / 2 - m_width / 2, geometry.top());
                         else
                             m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         m_height = size.height();
                     }
                     break;
                 case Qt::AlignLeft:
                 case Qt::AlignRight: {
                         QPointF point(0,0);
                         foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
                             LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 item->setGeometry(geometry);
                                 item->setPos(point);
                                 const QRectF &rect = item->boundingRect();
                                 qreal h = rect.height();
                                 size = size.expandedTo(rect.size());
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if (m_height < geometry.height())
                             m_legend->d_ptr->items()->setPos(geometry.left(), geometry.height() / 2 - m_height / 2);
                         else
                             m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         m_width = size.width();
                         break;
                         }
                     }
                 m_minOffsetX = -left;
                 m_minOffsetY = - top;
                 m_maxOffsetX = m_width - geometry.width() - right;
                 m_maxOffsetY = m_height - geometry.height() - bottom;
+                setOffset(oldOffsetX, oldOffsetY);
             }
             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.
+                qreal oldOffsetX = m_offsetX;
+                qreal oldOffsetY = m_offsetY;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 QSizeF size(0, 0);
                 QList<QLegendMarker *> markers = m_legend->d_ptr->markers();
                 if (markers.isEmpty())
                     return;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             item->setPos(point.x(),point.y());
                             const QRectF &boundingRect = item->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 > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() + h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignBottom: {
                     QPointF point(0, geometry.height());
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_width = qMax(m_width,w);
                             m_height = qMax(m_height,h);
                             item->setPos(point.x(),point.y() - h);
                             point.setX(point.x() + w);
                             if (point.x() + w > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() - h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -m_height + geometry.height() - top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = -bottom;
                 }
                 break;
                 case Qt::AlignLeft: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x(),point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom() - bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() + maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignRight: {
                     QPointF point(geometry.width(), 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x() - w,point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom()-bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() - maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = - m_width + geometry.width() - left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 default:
                     break;
                 }
+                setOffset(oldOffsetX, oldOffsetY);
             }
             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(constraint.isValid()) {
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                     size = size.boundedTo(constraint);
                 }
                 else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width+=item->effectiveSizeHint(which).width();
                         height=qMax(height,item->effectiveSizeHint(which).height());
                     }
                     size = QSizeF(qMin(constraint.width(),width), height);
                 }
                 else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width=qMax(width,item->effectiveSizeHint(which).width());
                         height+=height,item->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width,qMin(constraint.height(),height));
                 }
                 else {
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }
             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