HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1263:d5f432b5ffc0

legend detach example. Bug fixes to legend.

sauimone -

r1263:d5f432b5ffc0

parent child

Context file:

r1263:d5f432b5ffc0

Collapse all files

examples/legend/legend.pro created 644 +12 0

@@ -0,0 +1,12
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = legend
	6	SOURCES += main.cpp \
	7	mainwidget.cpp
	8
	9	!system_build:mac: QMAKE_POST_LINK += "$$MAC_POST_LINK_PREFIX $$MAC_EXAMPLES_BIN_DIR"
	10
	11	HEADERS += \
	12	mainwidget.h

examples/legend/main.cpp created 644 +41 0

@@ -0,0 +1,41
	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	#include <QChartView>
	26	#include <QBarSeries>
	27	#include <QBarSet>
	28	#include <QLegend>
	29
	30	QTCOMMERCIALCHART_USE_NAMESPACE
	31
	32	int main(int argc, char *argv[])
	33	{
	34	QApplication a(argc, argv);
	35
	36	MainWidget w;
	37	w.resize(1024,768);
	38	w.show();
	39
	40	return a.exec();
	41	}

examples/legend/mainwidget.cpp created 644 +134 0

@@ -0,0 +1,134
	1	#include "mainwidget.h"
	2	#include <QChart>
	3	#include <QChartView>
	4	#include <QPushButton>
	5	#include <QLabel>
	6	#include <QDebug>
	7	#include <QBarSet>
	8	#include <QBarSeries>
	9	#include <QLegend>
	10
	11	QTCOMMERCIALCHART_USE_NAMESPACE
	12
	13	MainWidget::MainWidget(QWidget *parent) :
	14	QWidget(parent)
	15	{
	16	m_setCount = 0;
	17	m_chart = new QChart();
	18
	19	m_buttonLayout = new QGridLayout();
	20	QPushButton *detachLegendButton = new QPushButton("detach legend");
	21	connect(detachLegendButton, SIGNAL(clicked()), this, SLOT(detachLegend()));
	22	m_buttonLayout->addWidget(detachLegendButton, 0, 0);
	23	QPushButton *attachLegendButton = new QPushButton("attach legend");
	24	connect(attachLegendButton, SIGNAL(clicked()), this, SLOT(attachLegend()));
	25	m_buttonLayout->addWidget(attachLegendButton, 1, 0);
	26
	27	QPushButton *addSetButton = new QPushButton("add barset");
	28	connect(addSetButton, SIGNAL(clicked()), this, SLOT(addBarset()));
	29	m_buttonLayout->addWidget(addSetButton, 2, 0);
	30	QPushButton *removeBarsetButton = new QPushButton("remove barset");
	31	connect(removeBarsetButton, SIGNAL(clicked()), this, SLOT(removeBarset()));
	32	m_buttonLayout->addWidget(removeBarsetButton, 3, 0);
	33
	34	// add row with empty label to make all the other rows static
	35	m_buttonLayout->addWidget(new QLabel(""), m_buttonLayout->rowCount(), 0);
	36	m_buttonLayout->setRowStretch(m_buttonLayout->rowCount() - 1, 1);
	37
	38	// Create chart view with the chart
	39	m_chartView = new QChartView(m_chart, this);
	40	m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
	41
	42	m_customView = new QGraphicsView(this);
	43	m_customScene = new QGraphicsScene(this);
	44	m_customView->setScene(m_customScene);
	45
	46	// Create layout for grid and detached legend
	47	m_mainLayout = new QGridLayout();
	48	m_mainLayout->addLayout(m_buttonLayout, 0, 0);
	49	m_mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
	50	m_mainLayout->addWidget(m_customView, 0, 2, 3, 1);
	51	setLayout(m_mainLayout);
	52
	53	createSeries();
	54	}
	55
	56	void MainWidget::createSeries()
	57	{
	58	//![1]
	59	m_series = new QBarSeries();
	60
	61	addBarset();
	62	addBarset();
	63	addBarset();
	64	addBarset();
	65	//![1]
	66
	67	//![2]
	68	m_chart->addSeries(m_series);
	69	m_chart->setTitle("Legend detach example");
	70	//![2]
	71
	72	//![3]
	73	m_chart->legend()->setVisible(true);
	74	m_chart->legend()->setAlignment(QLegend::AlignmentBottom);
	75	m_chart->axisY()->setNiceNumbersEnabled(true);
	76	//![3]
	77
	78	//![4]
	79	m_chartView->setRenderHint(QPainter::Antialiasing);
	80	//![4]
	81	}
	82
	83	void MainWidget::attachLegend()
	84	{
	85	qDebug() << "attach legend";
	86	QLegend *legend = m_chart->legend();
	87
	88	if (m_customScene->items().contains(legend)) {
	89	qDebug() << "legend removed from other scene";
	90	m_customScene->removeItem(legend);
	91	legend->setParent(m_chart);
	92	legend->attachToChart();
	93	}
	94
	95	// legend->attachToChart();
	96	// This causes redraw
	97	QSize size(1,1);
	98	this->resize(this->size() + size);
	99	this->resize(this->size() - size);
	100	}
	101
	102	void MainWidget::detachLegend()
	103	{
	104	qDebug() << "detach legend";
	105	QLegend *legend = m_chart->legend();
	106	legend->detachFromChart();
	107
	108	m_customScene->addItem(legend);
	109	// m_mainLayout->addWidget(legend,0,2,3,1);
	110	// setLayout(m_layout);
	111
	112	// TODO: layout legend to somewhere else
	113	// This causes redraw
	114	QSize size(1,1);
	115	this->resize(this->size() + size);
	116	this->resize(this->size() - size);
	117	}
	118
	119	void MainWidget::addBarset()
	120	{
	121	QBarSet *barSet = new QBarSet(QString("set ") + QString::number(m_setCount));
	122	m_setCount++;
	123	qreal delta = m_series->barsetCount() * 0.1;
	124	*barSet << QPointF(0.0 + delta, 1 + delta) << QPointF(1.0 + delta, 2 + delta) << QPointF(2.0 + delta, 3 + delta) << QPointF(3.0 + delta, 4 + delta);
	125	m_series->append(barSet);
	126	}
	127
	128	void MainWidget::removeBarset()
	129	{
	130	QList<QBarSet*> sets = m_series->barSets();
	131	if (sets.count() > 0) {
	132	m_series->remove(sets.at(sets.count()-1));
	133	}
	134	}

examples/legend/mainwidget.h created 644 +49 0

@@ -0,0 +1,49
	1	#ifndef MAINWIDGET_H
	2	#define MAINWIDGET_H
	3
	4	#include "qchartglobal.h"
	5	#include "qchart.h"
	6	#include "qchartview.h"
	7	#include <QWidget>
	8	#include <QGraphicsWidget>
	9	#include <QGridLayout>
	10	#include <QGraphicsGridLayout>
	11
	12	QTCOMMERCIALCHART_USE_NAMESPACE
	13
	14	class MainWidget : public QWidget
	15	//class MainWidget : public QGraphicsWidget
	16	{
	17	Q_OBJECT
	18	public:
	19	explicit MainWidget(QWidget *parent = 0);
	20
	21	void createSeries();
	22
	23	signals:
	24
	25	public slots:
	26	void attachLegend();
	27	void detachLegend();
	28	void addBarset();
	29	void removeBarset();
	30
	31	private:
	32
	33	QChart *m_chart;
	34	QBarSeries *m_series;
	35
	36	QGraphicsScene *m_scene;
	37	QChartView *m_chartView;
	38	QGridLayout *m_mainLayout;
	39	QGridLayout *m_buttonLayout;
	40
	41	QGraphicsView *m_customView;
	42	QGraphicsScene *m_customScene;
	43	QGraphicsGridLayout *m_customLayout;
	44
	45
	46	int m_setCount;
	47	};
	48
	49	#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 \
                        barchart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        presenterchart \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
                        modeldata \
-                       groupedbarchart
+                       groupedbarchart \
+                       legend

src/barchart/qbarseries.cpp +87 -49

             /****************************************************************************
             **
             ** 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 "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, QString category)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
-                // NOTE: d_ptr destroyed by QObject
+                Q_D(QBarSeries);
+                if(d->m_dataset){
+                    d->m_dataset->removeSeries(this);
+                }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Sets the \a categories, which are used to to group the data.
             */
             void QBarSeries::setCategories(QBarCategories categories)
             {
                 Q_D(QBarSeries);
                 d->setCategories(categories);
                 emit d->categoriesUpdated();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
-                if ((d->m_barSets.contains(set)) || (set == 0)) {
+                return d->append(set);
-                    // Fail if set is already in list or set is null.
-                    return false;
-                d->m_barSets.append(set);
-                QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
-                emit d->restructuredBars();
-                return true;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
-                if (!d->m_barSets.contains(set)) {
+                return d->remove(set);
-                    // Fail if set is not in list
-                    return false;
-                d->m_barSets.removeOne(set);
-                QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
-                emit d->restructuredBars();
-                return true;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
-                foreach (QBarSet* set, sets) {
+                return d->append(sets);
-                    if ((set == 0) || (d->m_barSets.contains(set))) {
-                        // Fail if any of the sets is null or is already appended.
-                        return false;
-                    if (sets.count(set) != 1) {
-                        // Also fail if same set is more than once in given list.
-                        return false;
-                foreach (QBarSet* set, sets) {
-                    d->m_barSets.append(set);
-                    QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
-                emit d->restructuredBars();
-                return true;
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
             bool QBarSeries::remove(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
+                return d->remove(sets);
-                bool setsRemoved = false;
-                foreach (QBarSet* set, sets) {
-                    if (d->m_barSets.contains(set)) {
-                        d->m_barSets.removeOne(set);
-                        QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
-                        setsRemoved = true;
-                if (setsRemoved) {
-                    emit d->restructuredBars();
-                return setsRemoved;
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->categories();
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->m_labelsVisible = visible;
                     emit d->updatedBars();
                 }
             }
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barMargin(0.05),  // Default value is 5% of category width
                 m_labelsVisible(false)
             {
             }
             void QBarSeriesPrivate::setCategories(QBarCategories categories)
             {
                 m_categories = categories;
             }
             void QBarSeriesPrivate::insertCategory(int index, const QString category)
             {
                 m_categories.insert(index, category);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::removeCategory(int index)
             {
                 m_categories.removeAt(index);
                 emit categoriesUpdated();
             }
             int QBarSeriesPrivate::categoryCount() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories.count();
                 }
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             QBarCategories QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
                 QBarCategories categories;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     categories.append(QString::number(i));
                 }
                 return categories;
             }
             void QBarSeriesPrivate::setBarMargin(qreal margin)
             {
                 if (margin > 1.0) {
                     margin = 1.0;
                 } else if (margin < 0.0) {
                     margin = 0.0;
                 }
                 m_barMargin = margin;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barMargin()
             {
                 return m_barMargin;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 if ((category >= 0) && (category < m_categories.count())) {
                     return m_categories.at(category);
                 }
                 return QString::number(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             void QBarSeriesPrivate::barsetChanged()
             {
                 emit updatedBars();
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, x) - 0.5;
                 minY = qMin(minY, y);
-                maxX = qMax(maxX, x) - 0.5;
+                maxX = qMax(maxX, x) + 0.5;
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
+            bool QBarSeriesPrivate::append(QBarSet *set)
+            {
+                Q_Q(QBarSeries);
+                if ((m_barSets.contains(set)) || (set == 0)) {
+                    // Fail if set is already in list or set is null.
+                    return false;
+                }
+                m_barSets.append(set);
+                QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
+                if (m_dataset) {
+                    m_dataset->updateSeries(q);   // this notifies legend
+                }
+                emit restructuredBars();      // this notifies barchartitem
+                return true;
+            }
+            bool QBarSeriesPrivate::remove(QBarSet *set)
+            {
+                Q_Q(QBarSeries);
+                if (!m_barSets.contains(set)) {
+                    // Fail if set is not in list
+                    return false;
+                }
+                m_barSets.removeOne(set);
+                QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
+                if (m_dataset) {
+                    m_dataset->updateSeries(q);   // this notifies legend
+                }
+                emit restructuredBars();        // this notifies barchartitem
+                return true;
+            }
+            bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
+            {
+                Q_Q(QBarSeries);
+                foreach (QBarSet* set, sets) {
+                    if ((set == 0) || (m_barSets.contains(set))) {
+                        // Fail if any of the sets is null or is already appended.
+                        return false;
+                    }
+                    if (sets.count(set) != 1) {
+                        // Also fail if same set is more than once in given list.
+                        return false;
+                    }
+                }
+                foreach (QBarSet* set, sets) {
+                    m_barSets.append(set);
+                    QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
+                }
+                if (m_dataset) {
+                    m_dataset->updateSeries(q);   // this notifies legend
+                }
+                emit restructuredBars();        // this notifies barchartitem
+                return true;
+            }
+            bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
+            {
+                Q_Q(QBarSeries);
+                bool setsRemoved = false;
+                foreach (QBarSet* set, sets) {
+                    if (m_barSets.contains(set)) {
+                        m_barSets.removeOne(set);
+                        QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
+                        setsRemoved = true;
+                    }
+                }
+                if (setsRemoved) {
+                    if (m_dataset) {
+                        m_dataset->updateSeries(q);   // this notifies legend
+                    }
+                    emit restructuredBars();        // this notifies barchartitem
+                }
+                return setsRemoved;
+            }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries_p.h +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
             class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarSeries *parent);
                 void setCategories(QBarCategories categories);
                 void insertCategory(int index, const QString category);
                 void removeCategory(int index);
                 int categoryCount() const;
                 QBarCategories categories() const;
                 void setBarMargin(qreal margin);
                 qreal barMargin();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
+                bool append(QBarSet *set);
+                bool remove(QBarSet *set);
+                bool append(QList<QBarSet* > sets);
+                bool remove(QList<QBarSet* > sets);
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void updatedBars();
                 void restructuredBars();
                 void categoriesUpdated();
                 void labelsVisibleChanged(bool visible);
             private Q_SLOTS:
                 void barsetChanged();
             protected:
                 QList<QBarSet *> m_barSets;
                 QBarCategories m_categories;
                 qreal m_barMargin;
                 bool m_labelsVisible;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/chartdataset.cpp +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QAxis(this)),
                 m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false),
                 m_axisYInitialized(false)
             {
                 //create main domain
                 Domain* domain = new Domain(m_axisY);
                 m_axisDomainMap.insert(m_axisY,domain);
                 QObject::connect(m_axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(m_axisX->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),m_axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),m_axisX->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    m_axisXInitialized=true;
                    emit axisAdded(m_axisX,domain);
                 }
                 if(!m_axisYInitialized && axisY==m_axisY){
                    m_axisYInitialized=true;
                    emit axisAdded(m_axisY,domain);
                 }
                 series->d_ptr->scaleDomain(*domain);
                 // Note that with SeriesTypeBar we don't set up categories, but use real values on x-asis
                 if(series->type() == QAbstractSeries::SeriesTypeGroupedBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 series->d_ptr->m_dataset=this;
                 emit seriesAdded(series,domain);
             }
             QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 series->d_ptr->m_dataset=0;
                 QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=m_axisY){
                         axis->setParent(0);
                         delete domain;
                     }else{
                         m_axisYInitialized=false;
                         m_axisDomainMap.insert(m_axisY,domain);
                     }
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
                     QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==1);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomIn(rect,size);
                 }
                 domain->zoomIn(rect,size);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomOut(rect,size);
                 }
                 domain->zoomOut(rect,size);
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->move(dx,dy,size);
                 }
                 domain->move(dx,dy,size);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisMap.keys();
             }
+            void ChartDataSet::updateSeries(QAbstractSeries *series)
+            {
+                emit seriesUpdated(series);
+            }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include "qabstractseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class QBarSeries;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries* series,QAxis *axisY = 0);
                 QAxis* removeSeries(QAbstractSeries* series);
                 void removeAllSeries();
+                void updateSeries(QAbstractSeries* series);
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(int dx,int dy,const QSizeF& size);
                 int seriesCount(QAbstractSeries::SeriesType type);
                 int seriesIndex(QAbstractSeries *series);
                 Domain* domain(QAbstractSeries* series) const;
                 Domain* domain(QAxis* axis) const;
                 QAxis* axisX() const { return m_axisX; }
                 QAxis* axisY(QAbstractSeries *series = 0) const;
                 QList<QAbstractSeries*> series() const;
             Q_SIGNALS:
                 void seriesAdded(QAbstractSeries* series, Domain* domain);
                 void seriesRemoved(QAbstractSeries* series);
+                void seriesUpdated(QAbstractSeries* series);
                 void axisAdded(QAxis* axis,Domain* domain);
                 void axisRemoved(QAxis* axis);
             private:
                 QStringList createLabels(QAxis* axis,qreal min, qreal max);
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
                 QMap<QAbstractSeries *, QAxis *> m_seriesAxisMap;
                 QMap<QAxis*, Domain *> m_axisDomainMap;
                 QMap<int, QAbstractSeries *> m_indexSeriesMap;
                 QAxis* m_axisX;
                 QAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
                 bool m_axisYInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/legend/qlegend.cpp +10 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_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 "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
              \enum QLegend::Alignment
              This enum describes the possible position for legend inside chart.
              \value AlignmentTop
              \value AlignmentBottom
              \value AlignmentLeft
              \value AlignmentRight
              */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
+                QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRect(boundingRect());
             }
             /*!
              Bounding rect of legend.
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
              Sets the \a alignment for legend. Legend tries to paint itself on the defined position in chart.
              \sa QLegend::Alignment
              */
             void QLegend::setAlignment(QLegend::Alignments alignment)
             {
                 if(d_ptr->m_alignment!=alignment && d_ptr->m_attachedToChart) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              Returns the preferred layout for legend
              */
             QLegend::Alignments QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
                 Sets the legend's scrolling offset to value defined by \a point.
             */
             void QLegend::setOffset(const QPointF& point)
             {
                 d_ptr->setOffset(point.x(),point.y());
             }
             /*!
                 Returns the legend's scrolling offset.
             */
             QPointF QLegend::offset() const
             {
                 return QPointF(d_ptr->m_offsetX,d_ptr->m_offsetY);
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible!=visible)
                 {
                     d_ptr->m_backgroundVisible=visible;
                     update();
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter,QLegend *q):
             q_ptr(q),
             m_presenter(presenter),
             m_markers(new QGraphicsItemGroup(q)),
             m_alignment(QLegend::AlignmentTop),
             m_offsetX(0),
             m_offsetY(0),
             m_minWidth(0),
             m_minHeight(0),
             m_width(0),
             m_height(0),
             m_attachedToChart(true),
             m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         if(m_width<=m_rect.width()) return;
                         if (x != m_offsetX) {
                             m_offsetX = qBound(qreal(0), x, m_width - m_rect.width());
                             m_markers->setPos(-m_offsetX,m_rect.top());
                         }
                         break;
                     }
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         if(m_height<=m_rect.height()) return;
                         if (y != m_offsetY) {
                             m_offsetY = qBound(qreal(0), y, m_height - m_rect.height());
                             m_markers->setPos(m_rect.left(),-m_offsetY);
                         }
                         break;
                     }
                 }
             }
             void QLegendPrivate::updateLayout()
             {
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             m_minWidth=qMax(m_minWidth,w);
                             m_minHeight=qMax(m_minHeight,rect.height());
                             m_width+=w;
                             point.setX(point.x() + w);
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point);
                             const QRectF& rect = item->boundingRect();
                             qreal h = rect.height();
                             m_minWidth=qMax(m_minWidth,rect.width());
                             m_minHeight=qMax(m_minHeight,h);
                             m_height+=h;
                             point.setY(point.y() + h);
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_presenter->updateLayout();
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker , markers)
                     m_markers->addToGroup(marker);
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
+            void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
+            {
+                // TODO: find out which markers are are added or removed. Update them
+                // TODO: better implementation
+                handleSeriesRemoved(series);
+                Domain domain;
+                handleSeriesAdded(series, &domain);
+            }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractSeries;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *chart,QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
                 void updateLayout();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 void handleSeriesRemoved(QAbstractSeries *series);
+                void handleSeriesUpdated(QAbstractSeries *series);
                 void handleUpdatePieSeries(); //TODO remove this function
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 QGraphicsItemGroup* m_markers;
                 QLegend::Alignments m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QRectF m_rect;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minWidth;
                 qreal m_minHeight;
                 qreal m_width;
                 qreal m_height;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
             friend class QLegend;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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