HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r786:3f886841e62a

updated theme example. minor fix to legend

sauimone -

r786:3f886841e62a

parent child

Context file:

r786:3f886841e62a

Collapse all files

demos/chartthemes/themewidget.cpp +17 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: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);
                         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/legendmarker.cpp +2 0

             #include "qchartglobal.h"
             #include "legendmarker_p.h"
             #include <qpieslice.h>
             #include <qbarset.h>
             #include <qxyseries.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)
                 {
                 case LegendMarkerTypeSeries: {
                     emit clicked(m_series,event->button());
                     break;
                     }
                 case LegendMarkerTypeBarset: {
                     emit clicked(m_barset,event->button());
                     break;
                     }
                 case LegendMarkerTypePieslice: {
                     emit clicked(m_pieslice,event->button());
                     break;
                     }
                 default: {
                     break;
                     }
                 }
             }
             void LegendMarker::changed()
             {
                 switch (m_type)
                 {
                 case LegendMarkerTypeSeries: {
                     QXYSeries* s = static_cast<QXYSeries*> (m_series);
+                    setPen(s->pen());
                     setBrush(s->brush());
                     setName(s->name());
                     break;
                 }
                 case LegendMarkerTypeBarset: {
+                    setPen(m_barset->pen());
                     setBrush(m_barset->brush());
                     setName(m_barset->name());
                     break;
                 }
                 case LegendMarkerTypePieslice: {
                     setBrush(m_pieslice->brush());
                     setName(m_pieslice->label());
                     break;
                 }
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.cpp +13 -13

             #include "qchartglobal.h"
             #include "qlegend.h"
             #include "qseries.h"
             #include "legendmarker_p.h"
             #include "legendscrollbutton_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \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(QGraphicsItem *parent) : QGraphicsObject(parent),
                 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);
                 connect(m_scrollButtonLeft, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 connect(m_scrollButtonRight, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 connect(m_scrollButtonUp, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 connect(m_scrollButtonDown, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 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);
                 connectSeries(series);
                 updateLayout();
             }
             /*!
                 \internal \a series Should be called when series is removed from chart.
             */
             void QLegend::handleSeriesRemoved(QSeries *series)
             {
                 disconnectSeries(series);
                 if (series->type() == QSeries::SeriesTypeArea) {
                     // This is special case. Area series has upper and lower series, which each have markers
                     QAreaSeries* s = static_cast<QAreaSeries *> (series);
                     deleteMarkers(s->upperSeries());
                     deleteMarkers(s->lowerSeries());
                 } else {
                     deleteMarkers(series);
                 }
                 updateLayout();
             }
             /*!
                 \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::handleScrollButtonClicked(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event);    // Maybe later something happens with right click...
                 LegendScrollButton* scrollButton = static_cast<LegendScrollButton *> (sender());
                 Q_ASSERT(scrollButton);
                 switch (scrollButton->id()) {
                 case LegendScrollButton::ScrollButtonIdLeft:
                 case LegendScrollButton::ScrollButtonIdUp: {
                     // Lower limit is same in these cases
                     mFirstMarker--;
                     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.
                 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)
             {
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
                     appendMarkers(lineSeries);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
                     appendMarkers(areaSeries->upperSeries());
                     if(areaSeries->lowerSeries())
                         appendMarkers(areaSeries->lowerSeries());
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries *barSeries = static_cast<QBarSeries *>(series);
                     appendMarkers(barSeries);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
                     appendMarkers(stackedBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
                     appendMarkers(percentBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     appendMarkers(scatterSeries);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     appendMarkers(pieSeries);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
                     appendMarkers(splineSeries);
                     break;
                 }
                 default: {
                     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()));
                 m_markers.append(marker);
                 childItems().append(marker);
             }
             /*!
                 \internal Helper function. Appends markers from  \a series to legend.
             */
             void QLegend::appendMarkers(QBarSeries *series)
             {
-                foreach(QBarSet* s, series->barSets()) {
+                foreach(QBarSet* set, series->barSets()) {
-                    LegendMarker* marker = new LegendMarker(series, s, this);
+                    LegendMarker* marker = new LegendMarker(series, set, this);
-                    marker->setName(s->name());
+                    marker->setName(set->name());
-                    marker->setPen(s->pen());
+                    marker->setPen(set->pen());
-                    marker->setBrush(s->brush());
+                    marker->setBrush(set->brush());
                     connect(marker, SIGNAL(clicked(QBarSet *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QBarSet *, Qt::MouseButton)));
-                    connect(s, SIGNAL(valueChanged()), marker, SLOT(changed()));
+                    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.
             */
             void QLegend::appendMarkers(QPieSeries *series)
             {
-                foreach(QPieSlice* s, series->slices()) {
+                foreach(QPieSlice* slice, series->slices()) {
-                    LegendMarker* marker = new LegendMarker(series, s, this);
+                    LegendMarker* marker = new LegendMarker(series, slice, this);
-                    marker->setName(s->label());
+                    marker->setName(slice->label());
-                    marker->setPen(s->pen());
+                    marker->setPen(slice->pen());
-                    marker->setBrush(s->brush());
+                    marker->setBrush(slice->brush());
                     connect(marker, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)));
-                    connect(s, SIGNAL(changed()), marker, SLOT(changed()));
+                    connect(slice, SIGNAL(changed()), marker, SLOT(changed()));
-                    connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
+                    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

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