HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1527:14e346f15b06

legend theme fix

sauimone -

r1527:14e346f15b06

parent child

Context file:

r1527:14e346f15b06

Collapse all files

src/charttheme.cpp +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qsplineseries.h"
             //items
             #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
                 chart->setDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
+                QFont font;
                 if (pen == legend->pen() || m_force)
                     legend->setPen(m_axisLinePen);
                 if (brush == legend->brush() || m_force)
                     legend->setBrush(m_chartBackgroundGradient);
+                // TODO: should legend have own brush & font defined by theme?
+                if (font == legend->font() || m_force)
+                    legend->setFont(m_labelFont);
+                if (brush == legend->labelBrush() || m_force)
+                    legend->setLabelBrush(m_axisLabelBrush);
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (d->m_data.m_slicePen.isThemed() || m_force)
                         d->setPen(penColor, true);
                     if (d->m_data.m_sliceBrush.isThemed() || m_force)
                         d->setBrush(brushColor, true);
                     if (d->m_data.m_labelBrush.isThemed() || m_force)
                         d->setLabelBrush(QBrush(m_titleBrush.color()), true);
                     if (d->m_data.m_labelFont.isThemed() || m_force)
                         d->setLabelFont(m_labelFont, true);
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker.cpp +22 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) :
                 QGraphicsObject(legend),
                 m_series(series),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this))
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
                 updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_textItem->setPen(pen);
                 updateLayout();
             }
             QPen LegendMarker::pen() const
             {
                 return m_textItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 updateLayout();
             }
             QFont LegendMarker::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarker::setLabel(const QString label)
             {
                 m_textItem->setText(label);
                 updateLayout();
             }
             void LegendMarker::setSize(const QSize& size)
             {
                 m_markerRect = QRectF(0,0,size.width(),size.height());
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
+            void LegendMarker::setLabelBrush(const QBrush &brush)
+            {
+                m_textItem->setBrush(brush);
+                updateLayout();
+            }
+            QBrush LegendMarker::labelBrush() const
+            {
+                return m_textItem->brush();
+            }
+            void LegendMarker::setLabelPen(const QPen &pen)
+            {
+                m_textItem->setPen(pen);
+                updateLayout();
+            }
+            QPen LegendMarker::labelPen() const
+            {
+                return m_textItem->pen();
+            }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::updateLayout()
             {
                 static const qreal margin = 2;
                 static const qreal space = 4;
                 const QRectF& textRect = m_textItem->boundingRect();
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
                 m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
                 m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker_p.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
             class LegendMarker : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 explicit LegendMarker(QAbstractSeries *m_series, QLegend *parent);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setSize(const QSize& size);
                 void setLabel(const QString label);
                 QString label() const;
+                void setLabelBrush(const QBrush &brush);
+                QBrush labelBrush() const;
+                void setLabelPen(const QPen &pen);
+                QPen labelPen() const;
                 QAbstractSeries *series() const { return m_series;}
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void updateLayout();
             protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             public Q_SLOTS:
                 virtual void updated() = 0;
             protected:
                 QAbstractSeries *m_series;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
                 QLegend* m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class XYLegendMarker : public LegendMarker
             {
             public:
                 XYLegendMarker(QXYSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QXYSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class AreaLegendMarker : public LegendMarker
             {
             public:
                 AreaLegendMarker(QAreaSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QAreaSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class BarLegendMarker : public LegendMarker
             {
             public:
                 BarLegendMarker(QBarSeries *barseries, QBarSet *barset,QLegend *legend);
             protected:
                 void updated();
             private:
                 QBarSet *m_barset;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class PieLegendMarker : public LegendMarker
             {
             public:
                 PieLegendMarker(QPieSeries *pieSeries, QPieSlice *pieslice, QLegend *legend);
             protected:
                 void updated();
             private:
                 QPieSlice *m_pieslice;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKER_P_H

src/legend/qlegend.cpp +72 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty color Legend::font
                 The font of markers used by legend
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              \internal
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->setFont(font);
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                 return d_ptr->m_font;
             }
+            void QLegend::setLabelPen(const QPen &pen)
+            {
+                if (d_ptr->m_labelPen != pen) {
+                    d_ptr->setLabelPen(pen);
+                    emit labelPenChanged(pen);
+                }
+            }
+            QPen QLegend::labelPen() const
+            {
+                return d_ptr->m_labelPen;
+            }
+            void QLegend::setLabelBrush(const QBrush &brush)
+            {
+                qDebug() << "setting legend brush 1";
+                if (d_ptr->m_labelBrush != brush) {
+                    d_ptr->setLabelBrush(brush);
+                    emit labelBrushChanged(brush);
+                    qDebug() << "setting legend brush 2";
+                }
+            }
+            QBrush QLegend::labelBrush() const
+            {
+                return d_ptr->m_labelBrush;
+            }
+            void QLegend::setLabelColor(QColor color)
+            {
+                QBrush b = d_ptr->m_labelBrush;
+                if (b.style() != Qt::SolidPattern || b.color() != color) {
+                    b.setStyle(Qt::SolidPattern);
+                    b.setColor(color);
+                    setLabelBrush(b);
+                    emit labelColorChanged(color);
+                }
+            }
+            QColor QLegend::labelColor() const
+            {
+                return d_ptr->m_labelBrush.color();
+            }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->attachToChart();
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_chart(chart),
                 m_markers(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
+                m_labelPen(QPen(Qt::NoPen)),
+                m_labelBrush(QBrush()),
                 m_offsetX(0),
                 m_offsetY(0),
                 m_minWidth(0),
                 m_minHeight(0),
                 m_width(0),
                 m_height(0),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         scrollHorizontal = true;
                         break;
                     }
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         scrollHorizontal = false;
                         break;
                     }
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_attachedToChart) {
                     scrollHorizontal = !scrollHorizontal;
                 }
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if(m_width<=m_rect.width()) return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_markers->setPos(-m_offsetX,m_rect.top());
                     }
                 } else {
                     if(m_height<=m_rect.height()) return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_markers->setPos(m_rect.left(),-m_offsetY);
                     }
                 }
             }
             QPointF QLegendPrivate::offset() const
             {
                 return QPointF(m_offsetX,m_offsetY);
             }
             void QLegendPrivate::updateLayout()
             {
                 if (!m_attachedToChart) {
                     updateDetachedLayout();
                     return;
                 }
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             if (item->isVisible()) {
                                 item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 m_minWidth=qMax(m_minWidth,w);
                                 m_minHeight=qMax(m_minHeight,rect.height());
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             if (item->isVisible()) {
                                 item->setPos(point);
                                 const QRectF& rect = item->boundingRect();
                                 qreal h = rect.height();
                                 m_minWidth=qMax(m_minWidth,rect.width());
                                 m_minHeight=qMax(m_minHeight,h);
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_minOffsetX = 0;
                 m_minOffsetY = 0;
                 m_maxOffsetX = m_width - m_rect.width();
                 m_maxOffsetY = m_height - m_rect.height();
                 m_presenter->updateLayout();
             }
             void QLegendPrivate::updateDetachedLayout()
             {
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX=0;
                 m_offsetY=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth = 0;
                 m_minHeight = 0;
                 switch (m_alignment) {
                     case Qt::AlignTop: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,w);
                                 m_minHeight = qMax(m_minHeight,rect.height());
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y());
                                 point.setX(point.x() + w);
                                 if (point.x() + w > m_rect.topLeft().x() + m_rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(m_rect.topLeft().x());
                                     point.setY(point.y() + h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.bottomLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,w);
                                 m_minHeight = qMax(m_minHeight,rect.height());
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y() - h);
                                 point.setX(point.x() + w);
                                 if (point.x() + w > m_rect.bottomLeft().x() + m_rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(m_rect.bottomLeft().x());
                                     point.setY(point.y() - h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = qMin(m_rect.topLeft().y(), m_rect.topLeft().y() - m_height + m_rect.height());
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = 0;
                     }
                     break;
                     case Qt::AlignLeft: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,rect.width());
                                 m_minHeight = qMax(m_minHeight,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x(),point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() + maxWidth);
                                     point.setY(m_rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topRight();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& rect = item->boundingRect();
                                 qreal w = rect.width();
                                 qreal h = rect.height();
                                 m_minWidth = qMax(m_minWidth,rect.width());
                                 m_minHeight = qMax(m_minHeight,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x() - w,point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() - maxWidth);
                                     point.setY(m_rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = qMin(m_rect.topLeft().x(), m_rect.topLeft().x() - m_width + m_rect.width());
                         m_minOffsetY = 0;
                         m_maxOffsetX = 0;
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     default:
                     break;
                 }
             }
             void QLegendPrivate::attachToChart()
             {
                 m_attachedToChart = true;
                 q_ptr->setParent(m_chart);
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::setFont(const QFont &font)
             {
                 m_font = font;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     marker->setFont(m_font);
                 }
                 updateLayout();
             }
+            void QLegendPrivate::setLabelPen(const QPen &pen)
+            {
+                m_labelPen = pen;
+                QList<QGraphicsItem *> items = m_markers->childItems();
+                foreach (QGraphicsItem *markers, items) {
+                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
+                    marker->setPen(m_labelPen);
+                }
+                updateLayout();
+            }
+            void QLegendPrivate::setLabelBrush(const QBrush &brush)
+            {
+                m_labelBrush = brush;
+                QList<QGraphicsItem *> items = m_markers->childItems();
+                foreach (QGraphicsItem *markers, items) {
+                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
+                    marker->setLabelBrush(m_labelBrush);
+                }
+                updateLayout();
+            }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers) {
                     marker->setFont(m_font);
+                    marker->setLabelPen(m_labelPen);
+                    marker->setLabelBrush(m_labelBrush);
                     m_markers->addToGroup(marker);
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         marker->setVisible(!marker->isVisible());
                     }
                 }
                 updateLayout();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +15 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #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 QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged)
+                Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
+            // TODO?
+            //    Q_PROPERTY(QColor labelBorderColor READ labelBorderColor WRITE setLabelBorderColor NOTIFY labelBorderColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setFont(const QFont &font);
                 QFont font() const;
+                void setLabelPen(const QPen &pen);
+                QPen labelPen() const;
+                void setLabelBrush(const QBrush &brush);
+                QBrush labelBrush() const;
+                void setLabelColor(QColor color);
+                QColor labelColor() const;
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 qreal minWidth() const;
                 qreal minHeight() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void fontChanged(QFont font);
+                void labelPenChanged(QPen pen);
+                void labelBrushChanged(QBrush brush);
+                void labelColorChanged(QColor color);
+            // TODO?
+            //    void labelBorderColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +4 0

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages