HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r792:f33d64d30a1c

legend refactoring.

sauimone -

r792:f33d64d30a1c

parent child

Context file:

r792:f33d64d30a1c

Collapse all files

demos/chartthemes/themewidget.cpp +2 -3

             /****************************************************************************
              **
              ** 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:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(100),
                 m_valueCount(11),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti aliasing")),
                 m_animatedComboBox(createAnimationBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     for (int j(0); j < valueCount; j++) {
                         QPointF value(j + (qreal) rand() / (qreal) RAND_MAX, qrand() % valueMax);
                         QString label = "Item " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->setTitle("Area chart");
                 {
                     QString name("Series ");
                     int nameIndex = 0;
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QLineSeries *series1 = new QLineSeries(chart);
                         QLineSeries *series2 = new QLineSeries(chart);
-                        series1->setName(name + QString::number(nameIndex) + QString(" lo"));
-                        series2->setName(name + QString::number(nameIndex) + QString(" hi"));
-                        nameIndex++;
                         foreach (Data data, m_dataTable[i]) {
                             series1->add(data.first);
                             series2->add(QPointF(data.first.x(), 0.0));
                         }
                         QAreaSeries *area = new QAreaSeries(series1, series2);
+                        area->setName(name + QString::number(nameIndex));
+                        nameIndex++;
                         chart->addSeries(area);
                     }
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->setTitle("Bar chart");
                 {
                     QBarCategories categories;
                     // TODO: categories
                     for (int i(0); i < valueCount; i++)
                         categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                     QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QBarSet *set = new QBarSet("Set" + QString::number(i));
                         foreach (Data data, m_dataTable[i])
                             *set << data.first.y();
                         series->appendBarSet(set);
                     }
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 // pie chart
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->add(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setPiePosition(hPos, 0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
             }

src/chartpresenter.cpp 0 -1

             #include "qchart.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
                 m_themeForce(false),
                 m_padding(50),
                 m_backgroundPadding(10)
             {
                 createConnections();
                 setTheme(QChart::ChartThemeDefault,false);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             void ChartPresenter::handleGeometryChanged()
             {
-                qDebug() << "legend h:" << m_chart->legend()->size().height();
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_padding,
                             m_padding + m_chart->legend()->size().height(),
                             -m_padding,
                             -m_padding);
                 //rewrite zoom stack
                 /*
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 */
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 Axis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	Chart *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarChartItem* bar = new BarChartItem(barSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries,this);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(pieSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart,m_themeForce);
                 m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_padding, -m_padding);
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	QSizeF size = geometry().size();
             	QRectF rect = geometry();
             	rect.translate(-m_padding, -m_padding);
             	m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legendmarker.cpp +31 -16

             #include "qchartglobal.h"
             #include "legendmarker_p.h"
             #include <qpieslice.h>
             #include <qbarset.h>
             #include <qxyseries.h>
+            #include <qareaseries.h>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QSeries *series, QGraphicsItem *parent) : QGraphicsObject(parent),
                 m_pos(0,0),
                 m_size(0,0),
                 m_boundingRect(0,0,0,0),
                 m_markerBoundingRect(0,0,0,0),
                 m_series(series),
                 m_barset(0),
                 m_pieslice(0),
-                m_type(LegendMarkerTypeSeries),
                 m_textItem(new QGraphicsSimpleTextItem(this))
             {
                 setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
             }
             LegendMarker::LegendMarker(QSeries *series, QBarSet *barset, QGraphicsItem *parent) : QGraphicsObject(parent),
                 m_pos(0,0),
                 m_size(0,0),
                 m_boundingRect(0,0,0,0),
                 m_markerBoundingRect(0,0,0,0),
                 m_series(series),
                 m_barset(barset),
                 m_pieslice(0),
-                m_type(LegendMarkerTypeBarset),
                 m_textItem(new QGraphicsSimpleTextItem(this))
             {
                 setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
             }
             LegendMarker::LegendMarker(QSeries *series, QPieSlice *pieslice, QGraphicsItem *parent) : QGraphicsObject(parent),
                 m_pos(0,0),
                 m_size(0,0),
                 m_boundingRect(0,0,0,0),
                 m_markerBoundingRect(0,0,0,0),
                 m_series(series),
                 m_barset(0),
                 m_pieslice(pieslice),
-                m_type(LegendMarkerTypePieslice),
                 m_textItem(new QGraphicsSimpleTextItem(this))
             {
                 setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
             }
             void LegendMarker::setPos(qreal x, qreal y)
             {
                 m_pos = QPointF(x,y);
                 layoutChanged();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_pen = pen;
             }
             QPen LegendMarker::pen() const
             {
                 return m_pen;
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_brush = brush;
             }
             QBrush LegendMarker::brush() const
             {
                 return m_brush;
             }
             void LegendMarker::setName(const QString name)
             {
                 m_textItem->setText(name);
                 layoutChanged();
             }
             QString LegendMarker::name() const
             {
                 return m_textItem->text();
             }
             QSeries* LegendMarker::series() const
             {
                 return m_series;
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawRect(m_markerBoundingRect);
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::layoutChanged()
             {
                 QSizeF markerSize(10,10);
                 qreal margin = 2;
                 m_size.setHeight(markerSize.height() + 2 * margin);
                 m_size.setWidth(m_textItem->boundingRect().width() + markerSize.width() + 3 * margin);
                 m_boundingRect = QRectF(m_pos.x(),m_pos.y(),m_size.width(),m_size.height());
                 m_markerBoundingRect = QRectF(m_pos.x() + margin, m_pos.y() + margin, markerSize.width(),markerSize.height());
                 m_textItem->setPos(m_pos.x() + markerSize.width() + 2 * margin, m_pos.y() + margin);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
-                switch (m_type)
+                switch (m_series->type()) {
+                case QSeries::SeriesTypeLine:
-                case LegendMarkerTypeSeries: {
+                case QSeries::SeriesTypeArea:
+                case QSeries::SeriesTypeScatter:
+                case QSeries::SeriesTypeSpline: {
                     emit clicked(m_series,event->button());
                     break;
                     }
-                case LegendMarkerTypeBarset: {
+                case QSeries::SeriesTypeBar:
+                case QSeries::SeriesTypeStackedBar:
+                case QSeries::SeriesTypePercentBar: {
                     emit clicked(m_barset,event->button());
                     break;
                     }
-                case LegendMarkerTypePieslice: {
+                case QSeries::SeriesTypePie: {
                     emit clicked(m_pieslice,event->button());
                     break;
                     }
                 default: {
                     break;
                     }
                 }
             }
             void LegendMarker::changed()
             {
-                switch (m_type)
+                switch (m_series->type()) {
+                case QSeries::SeriesTypeArea: {
-                case LegendMarkerTypeSeries: {
+                    QAreaSeries* s = static_cast<QAreaSeries*> (m_series);
-                    QXYSeries* s = static_cast<QXYSeries*> (m_series);
                     setPen(s->pen());
                     setBrush(s->brush());
                     setName(s->name());
                     break;
                 }
-                case LegendMarkerTypeBarset: {
+                case QSeries::SeriesTypeLine:
+                case QSeries::SeriesTypeScatter:
+                case QSeries::SeriesTypeSpline: {
+                    QXYSeries* s = static_cast<QXYSeries*> (m_series);
+                    setPen(s->pen());
+                    setBrush(s->brush());
+                    setName(s->name());
+                    break;
+                    }
+                case QSeries::SeriesTypeBar:
+                case QSeries::SeriesTypeStackedBar:
+                case QSeries::SeriesTypePercentBar: {
                     setPen(m_barset->pen());
                     setBrush(m_barset->brush());
                     setName(m_barset->name());
                     break;
+                    }
-                case LegendMarkerTypePieslice: {
+                case QSeries::SeriesTypePie: {
                     setBrush(m_pieslice->brush());
                     setName(m_pieslice->label());
                     break;
+                    }
+                default: {
+                    break;
+                    }
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legendmarker_p.h 0 -7

             #ifndef LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSeries;
             class QBarSet;
             class QPieSlice;
             // TODO: split this to 3 different markers for series, barset and pieslice. Current implementation is easier to misuse...
             class LegendMarker : public QGraphicsObject
             {
                 Q_OBJECT
-                enum LegendMarkerType {
-                    LegendMarkerTypeSeries,
-                    LegendMarkerTypeBarset,
-                    LegendMarkerTypePieslice
-                };
             public:
                 LegendMarker(QSeries *series, QGraphicsItem *parent = 0);
                 LegendMarker(QSeries *series, QBarSet *barset, QGraphicsItem *parent = 0);
                 LegendMarker(QSeries *series, QPieSlice *pieslice, QGraphicsItem *parent = 0);
                 void setPos(qreal x, qreal y);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setName(const QString name);
                 QString name() const;
                 QSeries* series() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void layoutChanged();
             public:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked(QSeries *series, Qt::MouseButton button);
                 void clicked(QBarSet *barset, Qt::MouseButton button);
                 void clicked(QPieSlice *pieslice, Qt::MouseButton button);
             public Q_SLOTS:
                 void changed();
             private:
                 QPointF m_pos;
                 QSize m_size;
                 QRectF m_boundingRect;
                 QRectF m_markerBoundingRect;
                 QBrush m_brush;
                 QPen m_pen;
                 QSeries *m_series;
                 QBarSet *m_barset;
                 QPieSlice *m_pieslice;
-                LegendMarkerType m_type;
                 QGraphicsSimpleTextItem *m_textItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKER_P_H

src/qlegend.cpp +80 -90

             #include "qlegend.h"
             #include "qchart_p.h"
             #include "qseries.h"
             #include "legendmarker_p.h"
             #include "legendscrollbutton_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 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.
                 \mainclass
                 \sa QChart, QSeries
             */
             /*!
                 \enum QLegend::Layout
                 This enum describes the possible position for legend inside chart.
                 \value LayoutTop
                 \value LayoutBottom
                 \value LayoutLeft
                 \value LayoutRight
             */
             /*!
                 \fn void QLegend::clicked(QSeries* series, Qt::MouseButton button)
                 \brief Notifies when series has been clicked on legend \a series \a button
             */
             /*!
                 \fn void QLegend::clicked(QBarSet* barset, Qt::MouseButton button)
                 \brief Notifies when barset has been clicked on legend \a barset \a button
             */
             /*!
                 \fn void QLegend::clicked(QPieSlice* slice, Qt::MouseButton button)
                 \brief Notifies when pie slice has been clicked on legend \a slice \a button
             */
             /*!
                 Constructs the legend object and sets the parent to \a parent
             */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
                 m_margin(5),
                 m_pos(0,0),
                 m_minimumSize(50,20),                // TODO: magic numbers
                 m_maximumSize(150,100),
                 m_size(m_minimumSize),
                 m_brush(Qt::darkGray),              // TODO: default should come from theme
                 m_alignment(QLegend::LayoutTop),
                 mFirstMarker(0)
             {
                 m_scrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
                 m_scrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
                 m_scrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
                 m_scrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
                 setZValue(ChartPresenter::LegendZValue);
             }
             /*!
                 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)
                 painter->setOpacity(opacity());
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
             //    painter->drawRect(boundingRect());
             }
             /*!
                 Bounding rect of legend.
             */
             QRectF QLegend::boundingRect() const
             {
                 return QRectF(m_pos,m_size);
             }
             /*!
                 Sets the \a brush of legend. Brush affects the background of legend.
             */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     update();
                 }
             }
             /*!
                 Returns the brush used by legend.
             */
             QBrush QLegend::brush() const
             {
                 return m_brush;
             }
             /*!
                 Sets the \a pen of legend. Pen affects the legend borders.
             */
             void QLegend::setPen(const QPen &pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     update();
                 }
             }
             /*!
                 Returns the pen used by legend
             */
             QPen QLegend::pen() const
             {
                 return m_pen;
             }
             /*!
                 Sets the \a preferred layout for legend. Legend tries to paint itself on the defined position in chart.
                 \sa QLegend::Layout
             */
             void QLegend::setAlignmnent(QLegend::Layout alignment)
             {
                 m_alignment = alignment;
                 updateLayout();
             }
             /*!
                 Returns the preferred layout for legend
             */
             QLegend::Layout QLegend::alignment() const
             {
                 return m_alignment;
             }
             /*!
                 Returns the maximum size of legend.
             */
             QSizeF QLegend::maximumSize() const
             {
                 return m_maximumSize;
             }
             /*!
                 Sets the maximum \a size for legend. The legend can't grow bigger than this size. If there are
                 more series than legend can fit to this size, scroll buttons are displayed.
             */
             void QLegend::setMaximumSize(const QSizeF size)
             {
                 m_maximumSize = size;
                 updateLayout();
             }
             /*!
                 Returns the current size of legend.
             */
             QSizeF QLegend::size() const
             {
                 return m_size;
             }
             /*!
                 Sets the \a size of legend. If size is bigger than maximum size of legend, the legend is resized to the maximum size.
                 \sa setMmaximumSize()
             */
             void QLegend::setSize(const QSizeF size)
             {
                 m_size = size;
                 if (m_size.width() > m_maximumSize.width()) {
                     m_size.setWidth(m_maximumSize.width());
                 }
                 if (m_size.height() > m_maximumSize.height()) {
                     m_size.setHeight(m_maximumSize.height());
                 }
             }
             /*!
                 Sets position of legend to \a pos
             */
             void QLegend::setPos(const QPointF &pos)
             {
                 m_pos = pos;
                 updateLayout();
             }
             /*!
                 \internal \a series \a domain Should be called when series is added to chart.
             */
             void QLegend::handleSeriesAdded(QSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
-                createMarkers(series);
+                switch (series->type())
-                connectSeries(series);
+                case QSeries::SeriesTypeLine: {
+                    QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
+                    appendMarkers(lineSeries);
+                    break;
+                }
+                case QSeries::SeriesTypeArea: {
+                    QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
+                    appendMarkers(areaSeries);
+                    break;
+                }
+                case QSeries::SeriesTypeBar: {
+                    QBarSeries *barSeries = static_cast<QBarSeries *>(series);
+                    appendMarkers(barSeries);
+                    break;
+                }
+                case QSeries::SeriesTypeStackedBar: {
+                    QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
+                    appendMarkers(stackedBarSeries);
+                    break;
+                }
+                case QSeries::SeriesTypePercentBar: {
+                    QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
+                    appendMarkers(percentBarSeries);
+                    break;
+                }
+                case QSeries::SeriesTypeScatter: {
+                    QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
+                    appendMarkers(scatterSeries);
+                    break;
+                }
+                case QSeries::SeriesTypePie: {
+                    QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
+                    appendMarkers(pieSeries);
+                    connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
+                    break;
+                }
+                case QSeries::SeriesTypeSpline: {
+                    QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
+                    appendMarkers(splineSeries);
+                    break;
+                }
+                default: {
+                    qWarning()<< "QLegend::handleSeriesAdded" << series->type() << "unknown series type.";
+                    break;
+                }
+                }
                 updateLayout();
             }
             /*!
                 \internal \a series Should be called when series is removed from chart.
             */
             void QLegend::handleSeriesRemoved(QSeries *series)
             {
-                disconnectSeries(series);
+                switch (series->type())
+                {
-                if (series->type() == QSeries::SeriesTypeArea) {
+                case QSeries::SeriesTypeArea: {
-                    // This is special case. Area series has upper and lower series, which each have markers
+                    QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
-                    QAreaSeries* s = static_cast<QAreaSeries *> (series);
+                    deleteMarkers(areaSeries);
-                    deleteMarkers(s->upperSeries());
+                    break;
-                    deleteMarkers(s->lowerSeries());
-                } else {
+                case QSeries::SeriesTypePie: {
+                    QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
+                    disconnect(pieSeries, SIGNAL(added(QList<QPieSlice *>)), this, SLOT(handleAdded(QList<QPieSlice *>)));
                     deleteMarkers(series);
+                    break;
+                }
+                default: {
+                    // All other types
+                    deleteMarkers(series);
+                    break;
+                }
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are added to pie chart.
             */
             void QLegend::handleAdded(QList<QPieSlice *> slices)
             {
                 QPieSeries* series = static_cast<QPieSeries *> (sender());
                 foreach(QPieSlice* s, slices) {
                     LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->label());
                     marker->setBrush(s->brush());
                     connect(marker, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),
                             this, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
                     connect(s, SIGNAL(changed()), marker, SLOT(changed()));
                     connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     m_markers.append(marker);
                     childItems().append(marker);
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are removed from pie chart. Currently unused,
                 because removed slices are also deleted and we listen destroyed signal
             */
             void QLegend::handleRemoved(QList<QPieSlice *> slices)
             {
                 Q_UNUSED(slices)
             }
             /*!
                 \internal Notifies legend that some marker has been removed. Sent by legend markers when destroyed
             */
             void QLegend::handleMarkerDestroyed()
             {
                 LegendMarker* m = static_cast<LegendMarker *> (sender());
                 m_markers.removeOne(m);
                 updateLayout();
             }
             /*!
                 \internal \a event Handles clicked signals from scroll buttons
             */
             void QLegend::scrollButtonClicked(LegendScrollButton *scrollButton)
             {
                  Q_ASSERT(scrollButton);
                 switch (scrollButton->id()) {
                 case LegendScrollButton::ScrollButtonIdLeft:
                 case LegendScrollButton::ScrollButtonIdUp: {
                     // Lower limit is same in these cases
                     mFirstMarker--;
                     checkFirstMarkerBounds();
                     break;
                 }
                 case LegendScrollButton::ScrollButtonIdRight:
                 case LegendScrollButton::ScrollButtonIdDown: {
                     mFirstMarker++;
                     checkFirstMarkerBounds();
                     break;
                 }
                 default: {
                     break;
                 }
                 }
                 updateLayout();
             }
             /*!
-                \internal Connects the \a series to legend. Legend listens changes in series, for example pie slices added / removed.
+                \internal Helper function. Appends markers from \a series to legend.
-                Not all series notify about events
-            */
-            void QLegend::connectSeries(QSeries *series)
-                // Connect relevant signals from series. Currently only pie series has interesting signals
-                // TODO: bar chart may have
-                if  (series->type() == QSeries::SeriesTypePie) {
-                    QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
-            /*!
-                \internal Disconnects \a series from legend. No more status updates from series to legend.
-            */
-            void QLegend::disconnectSeries(QSeries *series)
-                if (series->type() == QSeries::SeriesTypePie) {
-                    QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    disconnect(pieSeries, SIGNAL(added(QList<QPieSlice *>)), this, SLOT(handleAdded(QList<QPieSlice *>)));
-            /*!
-                \internal Creates new markers for \a series. Marker contains the colored rectangle and series name.
-                With pie chart, created markers depend on pie slices.
-                With bar chart, created markers depend on bar sets.
             */
-            void QLegend::createMarkers(QSeries *series)
+            void QLegend::appendMarkers(QAreaSeries* series)
             {
-                switch (series->type())
+                LegendMarker* marker = new LegendMarker(series,this);
+                marker->setName(series->name());
-                case QSeries::SeriesTypeLine: {
+                marker->setPen(series->pen());
-                    QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
+                marker->setBrush(series->brush());
-                    appendMarkers(lineSeries);
+                connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
-                    break;
+                connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
+                connect(series,SIGNAL(updated()),marker,SLOT(changed()));
-                case QSeries::SeriesTypeArea: {
+                m_markers.append(marker);
-                    QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
+                childItems().append(marker);
-                    appendMarkers(areaSeries->upperSeries());
-                    if(areaSeries->lowerSeries())
-                        appendMarkers(areaSeries->lowerSeries());
-                    break;
-                case QSeries::SeriesTypeBar: {
-                    QBarSeries *barSeries = static_cast<QBarSeries *>(series);
-                    appendMarkers(barSeries);
-                    break;
-                case QSeries::SeriesTypeStackedBar: {
-                    QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
-                    appendMarkers(stackedBarSeries);
-                    break;
-                case QSeries::SeriesTypePercentBar: {
-                    QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
-                    appendMarkers(percentBarSeries);
-                    break;
-                case QSeries::SeriesTypeScatter: {
-                    QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
-                    appendMarkers(scatterSeries);
-                    break;
-                case QSeries::SeriesTypePie: {
-                    QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    appendMarkers(pieSeries);
-                    break;
-                case QSeries::SeriesTypeSpline: {
-                    QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
-                    appendMarkers(splineSeries);
-                    break;
-                default: {
-                    qWarning()<< "QLegend::createMarkers" << series->type() << "unknown series type.";
-                    break;
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QXYSeries* series)
             {
                 LegendMarker* marker = new LegendMarker(series,this);
                 marker->setName(series->name());
                 marker->setPen(series->pen());
                 marker->setBrush(series->brush());
                 connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
                 connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
+                connect(series,SIGNAL(updated()),marker,SLOT(changed()));
                 m_markers.append(marker);
                 childItems().append(marker);
             }
             /*!
-                \internal Helper function. Appends markers from  \a series to legend.
+                \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QBarSeries *series)
             {
                 foreach(QBarSet* set, series->barSets()) {
                     LegendMarker* marker = new LegendMarker(series, set, this);
                     marker->setName(set->name());
                     marker->setPen(set->pen());
                     marker->setBrush(set->brush());
                     connect(marker, SIGNAL(clicked(QBarSet *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QBarSet *, Qt::MouseButton)));
                     connect(set, SIGNAL(valueChanged()), marker, SLOT(changed()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     m_markers.append(marker);
                     childItems().append(marker);
                 }
             }
             /*!
-                \internal Helper function. Appends markers from  \a series to legend.
+                \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QPieSeries *series)
             {
                 foreach(QPieSlice* slice, series->slices()) {
                     LegendMarker* marker = new LegendMarker(series, slice, this);
                     marker->setName(slice->label());
                     marker->setPen(slice->pen());
                     marker->setBrush(slice->brush());
                     connect(marker, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)));
                     connect(slice, SIGNAL(changed()), marker, SLOT(changed()));
                     connect(slice, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     m_markers.append(marker);
                     childItems().append(marker);
                 }
             }
             /*!
                 \internal Deletes all markers that are created from \a series
             */
             void QLegend::deleteMarkers(QSeries *series)
             {
                 // Search all markers that belong to given series and delete them.
                 foreach (LegendMarker *m, m_markers) {
                     if (m->series() == series) {
                         m_markers.removeOne(m);
                         delete m;
                     }
                 }
             }
             /*!
                 \internal Updates layout of legend. Tries to fit as many markers as possible up to the maximum size of legend.
                 If items don't fit, sets the visibility of scroll buttons accordingly.
                 Causes legend to be resized.
             */
             void QLegend::updateLayout()
             {
                 // Calculate layout for markers and text
                 if (m_markers.count() <= 0) {
                     // Nothing to do
                     return;
                 }
                 // Find out widest item.
                 QSizeF markerMaxSize = maximumMarkerSize();
                 checkFirstMarkerBounds();
                 // Use max height as scroll button size
                 rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
                 qreal totalWidth = 0;
                 qreal totalHeight = 0;
                 switch (m_alignment)
                 {
                 // Both cases organise items horizontally
                 case QLegend::LayoutBottom:
                 case QLegend::LayoutTop: {
                     qreal xStep = markerMaxSize.width();
                     qreal x = m_pos.x() + m_margin;
                     qreal y = m_pos.y() + m_margin;
                     int column = 0;
                     int maxColumns = 1;
                     qreal scrollButtonWidth = 0;
                     // Set correct visibility for scroll scrollbuttons
                     if (scrollButtonsVisible()) {
                         m_scrollButtonLeft->setVisible(true);
                         m_scrollButtonRight->setVisible(true);
                         // scrollbuttons visible, so add their width to total width
                         totalWidth += (m_scrollButtonLeft->boundingRect().width() + m_margin) * 2;
                         scrollButtonWidth = m_scrollButtonLeft->boundingRect().width() + m_margin;
                         // start position changes by scrollbutton width
                         x += scrollButtonWidth;
                     } else {
                         m_scrollButtonLeft->setVisible(false);
                         m_scrollButtonRight->setVisible(false);
                     }
                     m_scrollButtonUp->setVisible(false);
                     m_scrollButtonDown->setVisible(false);
                     for (int i=0; i < m_markers.count(); i++) {
                         LegendMarker *m = m_markers.at(i);
                         if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
                             if ((x + xStep + scrollButtonWidth + m_margin) > (m_pos.x() + m_maximumSize.width())) {
                                 // This marker would go outside legend rect.
                                 m->setVisible(false);
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
                                 m->setPos(x, y);
                                 x += xStep;
                                 column++;
                             }
                         }
                         maxColumns = column;
                     }
                     m_scrollButtonLeft->setPos(m_pos.x() + m_margin, y);
                     m_scrollButtonRight->setPos(x + m_margin, y);
                     totalWidth += maxColumns * markerMaxSize.width() + m_margin * 2;
                     totalHeight = markerMaxSize.height() + m_margin * 2;
                     break;
                 }
                 // Both cases organize items vertically
                 case QLegend::LayoutLeft:
                 case QLegend::LayoutRight: {
                     qreal yStep = markerMaxSize.height();
                     qreal x = m_pos.x() + m_margin;
                     qreal y = m_pos.y() + m_margin;
                     int row = 1;
                     int maxRows = 1;
                     qreal scrollButtonHeight = 0;
                     // Set correct visibility for scroll scrollbuttons
                     if (scrollButtonsVisible()) {
                         m_scrollButtonUp->setVisible(true);
                         m_scrollButtonDown->setVisible(true);
                         totalHeight += (m_scrollButtonUp->boundingRect().height() + m_margin) * 2;   // scrollbuttons visible, so add their height to total height
                         scrollButtonHeight = m_scrollButtonUp->boundingRect().height();
                         y += scrollButtonHeight + m_margin;                                         // start position changes by scrollbutton height
                     } else {
                         m_scrollButtonUp->setVisible(false);
                         m_scrollButtonDown->setVisible(false);
                     }
                     m_scrollButtonLeft->setVisible(false);
                     m_scrollButtonRight->setVisible(false);
                     for (int i=0; i < m_markers.count(); i++) {
                         LegendMarker* m = m_markers.at(i);
                         if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
                             if ((y + yStep + scrollButtonHeight) > (m_pos.y() + m_maximumSize.height())) {
                                 // This marker would go outside legend rect.
                                 m->setVisible(false);
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
                                 m->setPos(x, y);
                                 y += yStep;
                                 row++;
                             }
                         }
                         maxRows = row;
                     }
                     m_scrollButtonUp->setPos(m_pos.x() + m_margin, m_pos.y() + m_margin);
                     m_scrollButtonDown->setPos(m_pos.x() + m_margin, y + m_margin);
                     totalWidth += markerMaxSize.width() + m_margin * 2;
                     totalHeight = maxRows * markerMaxSize.height() + m_margin * 4 + scrollButtonHeight; // TODO: check this
                     break;
                 }
                 default: {
                     break;
                 }
                 }
                 m_size.setWidth(totalWidth);
                 m_size.setHeight(totalHeight);
                 update();
             }
             /*!
                 \internal Sets the size of scroll buttons to \a size
             */
             void QLegend::rescaleScrollButtons(const QSize &size)
             {
                 QPolygonF left;
                 left << QPointF(size.width(), 0) << QPointF(0, size.height() / 2) << QPointF(size.width(), size.height());
                 QPolygonF right;
                 right << QPointF(0, 0) << QPointF(size.width(), size.height() / 2) << QPointF(0, size.height());
                 QPolygonF up;
                 up << QPointF(0, size.height()) << QPointF(size.width() / 2,0) << QPointF(size.width(), size.height());
                 QPolygonF down;
                 down << QPointF(0, 0) << QPointF(size.width() / 2, size.height()) << QPointF(size.width(), 0);
                 m_scrollButtonLeft->setPolygon(left);
                 m_scrollButtonRight->setPolygon(right);
                 m_scrollButtonUp->setPolygon(up);
                 m_scrollButtonDown->setPolygon(down);
             }
             /*!
                 \internal Finds out maximum size of single marker. Marker sizes depend on series names.
             */
             QSizeF QLegend::maximumMarkerSize()
             {
                 QSizeF max(0,0);
                 foreach (LegendMarker* m, m_markers) {
                     if (m->boundingRect().width() > max.width())
                         max.setWidth(m->boundingRect().width());
                     if (m->boundingRect().height() > max.height())
                         max.setHeight(m->boundingRect().height());
                 }
                 return max;
             }
             /*!
                 \internal Checks that first marker is in acceptable bounds. Bounds range from 0 to (maximum number of markers - visible markers)
                 If scrollbuttons are visible, they affect the number of visible markers.
             */
             void QLegend::checkFirstMarkerBounds()
             {
                 if ((m_alignment == QLegend::LayoutLeft) || (m_alignment == QLegend::LayoutRight)) {
                     // Bounds limited by height.
                     int max;
                     if (scrollButtonsVisible()) {
                         max = (m_maximumSize.height() - m_scrollButtonLeft->boundingRect().height() * 2 - m_margin * 4) / maximumMarkerSize().height();
                     } else {
                         max = m_maximumSize.height() / maximumMarkerSize().height();
                     }
                     if (mFirstMarker > m_markers.count() - max)
                         mFirstMarker = m_markers.count() - max;
                 } else {
                     // Bounds limited by width
                     int max;
                     if (scrollButtonsVisible()) {
                         max = (m_maximumSize.width() - m_scrollButtonLeft->boundingRect().width() * 2 - m_margin*4) / maximumMarkerSize().width();
                     } else {
                         max = m_maximumSize.width() / maximumMarkerSize().width();
                     }
                     if (mFirstMarker > m_markers.count() - max)
                         mFirstMarker = m_markers.count() - max;
                 }
                 if (mFirstMarker < 0)
                     mFirstMarker = 0;
             }
             /*!
                 \internal Helper function. Visibility of scroll buttons isn't quite obvious, so helper function clarifies the logic.
             */
             bool QLegend::scrollButtonsVisible()
             {
                 // Just a helper to clarify, what the magic below means :)
                 if ((m_alignment == QLegend::LayoutTop) || (m_alignment == QLegend::LayoutBottom)) {
                     return (maximumMarkerSize().width() * m_markers.count() + m_margin * 2 > m_maximumSize.width());
                 } else if ((m_alignment == QLegend::LayoutLeft) || (m_alignment == QLegend::LayoutRight)) {
                     return (maximumMarkerSize().height() * m_markers.count() + m_margin * 2 > m_maximumSize.height());
                 }
                 return (maximumMarkerSize().height() * m_markers.count() + m_margin * 2 > m_maximumSize.height());
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h +3 -4

             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
+            class QAreaSeries;
             class LegendScrollButton;
             class QSeries;
             class QChart;
             // TODO: This as widget
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 // We only support these alignments (for now)
                 enum Layout {
                     LayoutTop = Qt::AlignTop,
                     LayoutBottom = Qt::AlignBottom,
                     LayoutLeft = Qt::AlignLeft,
                     LayoutRight = Qt::AlignRight
                 };
             private:
                 explicit QLegend(QChart *chart);
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setAlignmnent(QLegend::Layout alignment);
                 QLegend::Layout alignment() const;
                 QSizeF maximumSize() const;
                 void setMaximumSize(const QSizeF size);
                 QSizeF size() const;
                 void setSize(const QSizeF size);
                 void setPos(const QPointF &pos);
                 void scrollButtonClicked(LegendScrollButton *scrollButton);
             Q_SIGNALS:
                 // for interactions.
                 void clicked(QSeries *series, Qt::MouseButton button);
                 void clicked(QBarSet *barset, Qt::MouseButton button);
                 void clicked(QPieSlice *slice, Qt::MouseButton button);
             public Q_SLOTS:
                 // PIMPL --->
                 void handleSeriesAdded(QSeries *series, Domain *domain);
                 void handleSeriesRemoved(QSeries *series);
                 void handleAdded(QList<QPieSlice *> slices);
                 void handleRemoved(QList<QPieSlice *> slices);
                 void handleMarkerDestroyed();
                 // PIMPL <---
             private:
                 // PIMPL --->
-                void connectSeries(QSeries *series);
+                void appendMarkers(QAreaSeries *series);
-                void disconnectSeries(QSeries *series);
+                void appendMarkers(QXYSeries *series);
-                void createMarkers(QSeries *series);
-                void appendMarkers(QXYSeries *series);      // All line series are derived from QXYSeries, so this works for now
                 void appendMarkers(QBarSeries *series);
                 void appendMarkers(QPieSeries *series);
                 void deleteMarkers(QSeries *series);
                 void updateLayout();
                 void rescaleScrollButtons(const QSize &size);
                 QSizeF maximumMarkerSize();
                 void checkFirstMarkerBounds();
                 bool scrollButtonsVisible();
                 qreal m_margin;
                 QPointF m_pos;
                 QSizeF m_minimumSize;
                 QSizeF m_maximumSize;
                 QSizeF m_size;
                 QList<LegendMarker *> m_markers;
                 QBrush m_brush;
                 QPen m_pen;
                 QLegend::Layout m_alignment;
                 int mFirstMarker;
                 LegendScrollButton *m_scrollButtonLeft;
                 LegendScrollButton *m_scrollButtonRight;
                 LegendScrollButton *m_scrollButtonUp;
                 LegendScrollButton *m_scrollButtonDown;
                 friend class QChart;
                 // <--- PIMPL
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

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