HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2167:39840e10ebaa

refactoring

sauimone -

r2167:39840e10ebaa

parent child

Context file:

r2167:39840e10ebaa

Collapse all files

src/legend/legendmarkeritem.cpp +10 -88

             /****************************************************************************
              **
              ** 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 "legendmarkeritem_p.h"
-            #include "qxyseries.h"
-            #include "qxyseries_p.h"
-            #include "qlegend.h"
-            #include "qabstractbarseries.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>
+            #include "qlegendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            LegendMarkerItem::LegendMarkerItem(QAbstractSeries *series, QGraphicsObject *parent) :
+            //LegendMarkerItem::LegendMarkerItem(QAbstractSeries *series, QGraphicsObject *parent) :
+            LegendMarkerItem::LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
-                m_series(series),
+                m_marker(marker),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
                 m_margin(4),
                 m_space(4)
             {
-                //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
+                qDebug() << "LegendMarkerItem created for marker:" << m_marker;
+                setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
             }
             void LegendMarkerItem::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
             }
             QPen LegendMarkerItem::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarkerItem::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarkerItem::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 QFontMetrics fn(font);
                 m_markerRect = QRectF(0,0,fn.height()/2,fn.height()/2);
                 updateGeometry();
             }
             QFont LegendMarkerItem::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarkerItem::setLabel(const QString label)
             {
                 m_text = label;
                 updateGeometry();
             }
             QString LegendMarkerItem::label() const
             {
                 return m_text;
             }
             QRectF LegendMarkerItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarkerItem::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::labelBrush() const
             {
                 return m_textItem->brush();
             }
             void LegendMarkerItem::setGeometry(const QRectF& rect)
             {
                 QFontMetrics fn (font());
                 int width = rect.width();
                 qreal x = m_margin + m_markerRect.width() +  m_space + m_margin;
                 qreal y = qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin);
                 if (fn.boundingRect(m_text).width() + x > width)
                 {
                     QString string = m_text + "...";
                     while(fn.boundingRect(string).width() + x > width && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                     m_textItem->setText(string);
                 }
                 else
                     m_textItem->setText(m_text);
                 const QRectF& textRect = m_textItem->boundingRect();
                 m_textItem->setPos(x-m_margin,y/2 - textRect.height()/2);
                 m_rectItem->setRect(m_markerRect);
                 m_rectItem->setPos(m_margin,y/2  - m_markerRect.height()/2);
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,x+textRect.width()+m_margin,y);
             }
             void LegendMarkerItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarkerItem::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(m_textItem->font());
                 QSizeF sh;
                   switch (which) {
                     case Qt::MinimumSize:
                         sh = QSizeF(fn.boundingRect("...").width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     case Qt::PreferredSize:
                         sh = QSizeF(fn.boundingRect(m_text).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     default:
                       break;
                   }
                   return sh;
             }
             void LegendMarkerItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 qDebug() << "LegendMarkerItem::mousePressEvent";
-                QGraphicsObject::mousePressEvent(event);
+            //    QGraphicsObject::mousePressEvent(event);
                 //TODO: selected signal removed for now
+                emit m_marker->handleMousePressEvent(event);
+                QGraphicsItem::mousePressEvent(event);
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            AreaLegendMarkerItem::AreaLegendMarkerItem(QAreaSeries *series,QLegend *legend) : LegendMarkerItem(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 AreaLegendMarkerItem::updated()
-                setBrush(m_series->brush());
-                setLabel(m_series->name());
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            BarLegendMarkerItem::BarLegendMarkerItem(QAbstractBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarkerItem(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 BarLegendMarkerItem::updated()
-                setBrush(m_barset->brush());
-                setLabel(m_barset->label());
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            PieLegendMarkerItem::PieLegendMarkerItem(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarkerItem(series,legend),
-            m_pieslice(pieslice)
-            //    QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
-            //    QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
-                updated();
-            void PieLegendMarkerItem::updated()
-                setBrush(m_pieslice->brush());
-                setLabel(m_pieslice->label());
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            XYLegendMarkerItem::XYLegendMarkerItem(QXYSeries *series, QLegend *legend) : LegendMarkerItem(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 XYLegendMarkerItem::updated()
-                setLabel(m_series->name());
-                if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
-                    setBrush(m_series->brush());
-                else {
-                    setBrush(QBrush(m_series->pen().color()));
             }
             #include "moc_legendmarkeritem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem_p.h +4 -57

             /****************************************************************************
             **
             ** 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 LEGENDMARKERITEM_P_H
             #define LEGENDMARKERITEM_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             #include <QGraphicsLayoutItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QAbstractSeries;
+            class QLegendMarkerPrivate;
-            class QAreaSeries;
-            class QXYSeries;
-            class QBarSet;
-            class QAbstractBarSeries;
-            class QPieSlice;
-            class QLegend;
-            class QPieSeries;
             class LegendMarkerItem : public QGraphicsObject, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
-                explicit LegendMarkerItem(QAbstractSeries *m_series, QGraphicsObject *parent = 0);
+            //    explicit LegendMarkerItem(QAbstractSeries *m_series, QGraphicsObject *parent = 0);
+                explicit LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent = 0);
                 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 setLabel(const QString label);
                 QString label() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
-                QAbstractSeries *series() const { return m_series;}
                 void setGeometry(const QRectF& rect);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QSizeF sizeHint (Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
-            //public Q_SLOTS:
-                //virtual void updated() = 0;
             protected:
-                QAbstractSeries *m_series;
+                QLegendMarkerPrivate *m_marker;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
-            //    QLegend* m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;
                 qreal m_space;
                 QString m_text;
             };
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            class XYLegendMarkerItem : public LegendMarkerItem
-            public:
-                XYLegendMarkerItem(QXYSeries *series, QLegend *legend);
-            protected:
-                void updated();
-            private:
-                QXYSeries *m_series;
-            };
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            class AreaLegendMarkerItem : public LegendMarkerItem
-            public:
-                AreaLegendMarkerItem(QAreaSeries *series, QLegend *legend);
-            protected:
-                void updated();
-            private:
-                QAreaSeries *m_series;
-            };
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            class BarLegendMarkerItem : public LegendMarkerItem
-            public:
-                BarLegendMarkerItem(QAbstractBarSeries *barseries, QBarSet *barset,QLegend *legend);
-            protected:
-                void updated();
-            private:
-                QBarSet *m_barset;
-            };
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            class PieLegendMarkerItem : public LegendMarkerItem
-            public:
-                PieLegendMarkerItem(QPieSeries *pieSeries, QPieSlice *pieslice, QLegend *legend);
-            protected:
-                void updated();
-            private:
-                QPieSlice *m_pieslice;
-            };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKERITEM_P_H

src/legend/qlegend.cpp +38 -3

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** 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 "legendlayout_p.h"
-            #include "legendmarker_p.h"
+            #include "legendmarker_p.h" // TODO: deprecated
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qabstractbarseries.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 "chartlayout_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             #include <QLegendMarker>
+            #include "qlegendmarker_p.h"
+            #include "legendmarkeritem_p.h"
             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 Font Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \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 void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             /*!
              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*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 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()));
             }
             /*!
              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();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              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);
                 }
             }
             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();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
                     foreach (LegendMarker *marker, d_ptr->markers())
                         marker->setFont(d_ptr->m_font);
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                 return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                         // Note: The pen of the marker rectangle could be exposed in the public QLegend API
                         // instead of mapping it from label brush color
                         marker->setPen(brush.color());
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             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);
                 }
             }
             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;
                     layout()->invalidate();
                 }
             }
             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;
                 layout()->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
                 layout()->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              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;
             }
             QList<QLegendMarker*> QLegend::markers() const
             {
                 // TODO: name of PIMPL method will change.
                 return d_ptr->legendMarkers();
             }
+            void QLegend::appendSeries(QAbstractSeries* series)
+            {
+                d_ptr->appendSeries(series);
+            }
+            void QLegend::removeSeries(QAbstractSeries* series)
+            {
+                d_ptr->removeSeries(series);
+            }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 if (isAttachedToChart())
                     d_ptr->m_presenter->layout()->invalidate();
                 QGraphicsWidget::hideEvent(event);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 if (isAttachedToChart()) {
                     d_ptr->items()->setVisible(false);
                     layout()->invalidate();
                 }
                 QGraphicsWidget::showEvent(event);
                 //layout activation will show the items
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q)
                 : q_ptr(q),
                   m_presenter(presenter),
                   m_layout(new LegendLayout(q)),
                   m_chart(chart),
                   m_items(new QGraphicsItemGroup(q)),
                   m_alignment(Qt::AlignTop),
                   m_brush(QBrush()),
                   m_pen(QPen()),
                   m_labelBrush(QBrush()),
                   m_diameter(5),
                   m_attachedToChart(true),
                   m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 m_layout->setOffset(x, y);
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100 * m_diameter / int(size);
             }
+            void QLegendPrivate::appendSeries(QAbstractSeries* series)
+            {
+                Q_UNUSED(series);
+                // TODO:
+                /*
+                if (!m_series.contains(series)) {
+                    m_series.append(series);
+                    handleSeriesAdded(series,0);    // Dummy domain
+                }
+                */
+            }
+            void QLegendPrivate::removeSeries(QAbstractSeries* series)
+            {
+                Q_UNUSED(series);
+                // TODO:
+                /*
+                if (m_series.contains(series)) {
+                    m_series.removeOne(series);
+                    handleSeriesRemoved(series);
+                }
+                */
+            }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 qDebug() << "QLegendPrivate::handleSeriesAdded";
             // New markers --->
                 QList<QLegendMarker*> newMarkers = series->d_ptr->createLegendMarkers(q_ptr);
                 foreach (QLegendMarker* marker, newMarkers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                     marker->setVisible(series->isVisible());
-            // TODO: QLegendMarker has QGraphicsItem vs QLegendMarker is QGraphicsItem
             // TODO: possible hazard. What if marker is deleted and group still has pointer?
-            //        m_items->addToGroup(marker->d_ptr.data());
+                    m_items->addToGroup(marker->d_ptr.data()->item());
+            //        qDebug() << "item:" << marker->d_ptr.data()->item();
                     m_legendMarkers << marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
             // <--- New markers
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach (LegendMarker *marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                     marker->setVisible(series->isVisible());
                     m_items->addToGroup(marker);
                     m_markers << marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 QObject::connect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 m_items->setVisible(false);
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
             // New markers --->
                 foreach (QLegendMarker *marker, m_legendMarkers) {
                     if (marker->series() == series) {
                         delete marker;
                         m_legendMarkers.removeAll(marker);
                     }
                 }
                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
             // <--- New markers
                 foreach (LegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         delete marker;
                         m_markers.removeAll(marker);
                     }
                 }
                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 QObject::disconnect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
             // New markers --->
                 foreach (QLegendMarker* marker, m_legendMarkers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                     }
                 }
             // <--- New markers
                 foreach (LegendMarker* marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                 }
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleCountChanged()
             {
                 // With new markers, the series shoud notify markers directly?
                 // Handle new or removed markers
                 // Handle changes of marker pen/brush/label. every property that legend is interested
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +3 -6

             /****************************************************************************
             **
             ** 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.h>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QPieSlice;
-            class QXYSeries;
-            class QBarSet;
-            class QAbstractBarSeries;
-            class QPieSeries;
-            class QAreaSeries;
             class QChart;
             class QLegendPrivate;
             class QLegendMarker;
+            class QAbstractSeries;
             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)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 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 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();
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 // New stuff:
                 QList <QLegendMarker*> markers() const;
+                void appendSeries(QAbstractSeries* series);
+                void removeSeries(QAbstractSeries* series);
             protected:
                 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 labelColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
                 friend class LegendLayout;
                 friend class ChartLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +3 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 LegendLayout;
             class LegendMarker;
             class Domain;
             class QLegendMarker;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
                 QPointF offset() const;
                 int roundness(qreal size);
                 QList<LegendMarker*> markers() { return m_markers; }    // TODO: this will be removed
                 QGraphicsItemGroup* items() { return m_items; }
                 // New stuff:
                 QList<QLegendMarker*> legendMarkers() { return m_legendMarkers; }   // TODO: function name will change
+                void appendSeries(QAbstractSeries* series);
+                void removeSeries(QAbstractSeries* series);
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleSeriesVisibleChanged();
                 void handleCountChanged();
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 LegendLayout *m_layout;
                 QChart* m_chart;
                 QGraphicsItemGroup* m_items;
                 QList<LegendMarker*> m_markers;     // TODO: this will be removed
                 Qt::Alignment m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QFont m_font;
                 QBrush m_labelBrush;
                 qreal m_diameter;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
                 friend class QLegend;
                 friend class LegendLayout;
                 QList<QLegendMarker*> m_legendMarkers;  // TODO: rename to m_markers eventually.
+                QList<QAbstractSeries*> m_series;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/legend/qlegendmarker.cpp +23 -7

             /****************************************************************************
              **
              ** 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 "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include <QDebug>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*
             QLegendMarker::QLegendMarker(QAbstractSeries* series, QObject *parent) :
                 QObject(parent),
                 d_ptr(new QLegendMarkerPrivate(series, this))
             {
             }
+            */
+            QLegendMarker::QLegendMarker(QLegendMarkerPrivate &d, QObject *parent) :
+                QObject(parent),
+                d_ptr(&d)
+            {
+            }
             QLegendMarker::~QLegendMarker()
             {
             }
             QString QLegendMarker::label() const
             {
                 return d_ptr->m_label;
             }
             void QLegendMarker::setLabel(const QString &label)
             {
                 d_ptr->m_label = label;
             }
             QBrush QLegendMarker::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegendMarker::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->m_labelBrush = brush;
             }
             QFont QLegendMarker::font() const
             {
                 return d_ptr->m_font;
             }
             void QLegendMarker::setFont(const QFont &font)
             {
                 d_ptr->m_font = font;
             }
             QPen QLegendMarker::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegendMarker::setPen(const QPen &pen)
             {
                 d_ptr->m_pen = pen;
             }
             QBrush QLegendMarker::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegendMarker::setBrush(const QBrush &brush)
             {
                 d_ptr->m_brush = brush;
             }
             bool QLegendMarker::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             void QLegendMarker::setVisible(bool visible)
             {
                 d_ptr->m_visible = visible;
             }
-            QAbstractSeries* QLegendMarker::series()
-                return d_ptr->m_series;
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            /*
             QLegendMarkerPrivate::QLegendMarkerPrivate(QAbstractSeries *series, QLegendMarker *q) :
                 q_ptr(q),
                 m_series(series)
             {
                 m_item = new LegendMarkerItem(m_series);
             }
+            */
+            QLegendMarkerPrivate::QLegendMarkerPrivate(QLegendMarker *q) :
+                q_ptr(q)
+            {
+                qDebug() << "QLegendMarkerPrivate created";
+                m_item = new LegendMarkerItem(this);
+            }
             QLegendMarkerPrivate::~QLegendMarkerPrivate()
             {
             }
+            void QLegendMarkerPrivate::handleMousePressEvent(QGraphicsSceneEvent *event)
+            {
+                // Just emit clicked signal for now
+                Q_UNUSED(event);
+                Q_Q(QLegendMarker);
+                emit q->clicked();
+            }
             #include "moc_qlegendmarker.cpp"
             #include "moc_qlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegendmarker.h +9 -5

             /****************************************************************************
              **
              ** 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 QLEGENDMARKER_H
             #define QLEGENDMARKER_H
             #include <QChartGlobal>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendMarkerPrivate;
             class QAbstractSeries;
             // TODO: should this be QAbstractLegendMarker?
             class QTCOMMERCIALCHART_EXPORT QLegendMarker : public QObject
             {
                 Q_OBJECT
             // TODO: need for these?
             //    Q_PROPERTY(QString label READ label WRITE setlabel NOTIFY labelChanged);
             //    Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged);
             //    Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged);
             public:
-                explicit QLegendMarker(QAbstractSeries* series, QObject *parent = 0);
+            //    explicit QLegendMarker(QAbstractSeries* series, QObject *parent = 0);
                 virtual ~QLegendMarker();
                 QString label() const;
                 void setLabel(const QString &label);
                 QBrush labelBrush() const;
                 void setLabelBrush(const QBrush &brush);
                 QFont font() const;
                 void setFont(const QFont &font);
                 QPen pen() const;
                 void setPen(const QPen &pen);
                 QBrush brush() const;
                 void setBrush(const QBrush &brush);
                 bool isVisible() const;
                 void setVisible(bool visible);
-            //    virtual QAbstractSeries::SeriesType type() = 0;
+            //    virtual QAbstractSeries::SeriesType type() = 0; // TODO?
-                virtual QAbstractSeries* series();
+                virtual QAbstractSeries* series() = 0;
                 virtual QObject* peerObject() = 0;
+            protected:
+                explicit QLegendMarker(QLegendMarkerPrivate &d, QObject *parent = 0);
             Q_SIGNALS:
                 void clicked();
                 void hovered(bool status);
             public Q_SLOTS:
                 virtual void updated() = 0;  // TODO: private. Idea is that series signals, when some property has changed
-            public:
+            protected:
                 QScopedPointer<QLegendMarkerPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegendMarker)
+                friend class QLegendPrivate;
+                friend class QLegendMarkerPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGENDMARKER_H

src/legend/qlegendmarker_p.h +11 -13

             /****************************************************************************
             **
             ** 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 QLEGENDMARKERPRIVATE_H
             #define QLEGENDMARKERPRIVATE_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             #include <QGraphicsLayoutItem>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // TODO: check these
             class QAbstractSeries;
             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
             class QAbstractBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
             class QLegendMarker;
             class LegendMarkerItem;
             class QLegendMarkerPrivate : public QObject
             {
                 Q_OBJECT
             public:
-                explicit QLegendMarkerPrivate(QAbstractSeries *series, QLegendMarker *q);
+            //    explicit QLegendMarkerPrivate(QAbstractSeries *series, QLegendMarker *q);
+                explicit QLegendMarkerPrivate(QLegendMarker *q);
                 virtual ~QLegendMarkerPrivate();
             /*
                 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 setLabel(const QString label);
                 QString label() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
             */
+                // Helper for now.
+                LegendMarkerItem* item() const { return m_item; }
+                // Item gets the event, logic for event is here
+                void handleMousePressEvent(QGraphicsSceneEvent *event);
             public Q_SLOTS:
                 virtual void updated() {};
-            private:
+            protected:
-                QLegendMarker *q_ptr;
                 LegendMarkerItem *m_item;
+            private:
+                QLegendMarker *q_ptr;
             /*
                 QLegend* m_legend;
             */
             // New legend marker properties
-                QAbstractSeries* m_series;
                 QString m_label;
                 QBrush m_labelBrush;
                 QFont m_font;
                 QPen m_pen;
                 QBrush m_brush;
                 bool m_visible;
-            // Implementation details of new marker
-                QRectF m_markerRect;
-                QRectF m_boundingRect;
-                QGraphicsSimpleTextItem *m_textItem;
-                QGraphicsRectItem *m_rectItem;
-                qreal m_margin;
-                qreal m_space;
                 friend class QLegendPrivate; // TODO: Is this needed?
                 Q_DECLARE_PUBLIC(QLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGENDMARKERPRIVATE_H

src/legend/qpielegendmarker.cpp +39 -10

             /****************************************************************************
             **
             ** 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 "qpielegendmarker.h"
             #include "qpielegendmarker_p.h"
             #include <QPieSeries>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*
             QPieLegendMarker::QPieLegendMarker(QPieSeries* series, QPieSlice* slice, QObject *parent) :
                 QLegendMarker(series, parent),
-                m_slice(slice)
+                d_ptr(new QPieLegendMarkerPrivate(series,slice,this))
             {
                 QObject::connect(slice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(slice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
-            QPieSlice* QPieLegendMarker::peerObject()
+            */
+            QPieLegendMarker::QPieLegendMarker(QPieSeries* series, QPieSlice* slice, QObject *parent) :
+                QLegendMarker(*new QPieLegendMarkerPrivate(series,slice,this), parent)
+            {
+                QObject::connect(slice, SIGNAL(labelChanged()), this, SLOT(updated()));
+                QObject::connect(slice, SIGNAL(brushChanged()), this, SLOT(updated()));
+            //    updated();
+            }
+            /*!
+                \internal
+            */
+            QPieLegendMarker::QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent) :
+                QLegendMarker(d, parent)
             {
-                return m_slice;
             }
-            void QPieLegendMarker::updated()
+            QAbstractSeries* QPieLegendMarker::series()
             {
-                // TODO: to PIMPL.
+                Q_D(QPieLegendMarker);
-                setBrush(m_slice->brush());
+                return d->m_series;
-                setLabel(m_slice->label());
+            QPieSlice* QPieLegendMarker::peerObject()
+            {
+                Q_D(QPieLegendMarker);
+                return d->m_slice;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QAbstractSeries *series, QPieLegendMarker *q) :
+            //QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QAbstractSeries *series, QPieLegendMarker *q) :
-                QLegendMarkerPrivate(series, q)
+            QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QPieSeries *series, QPieSlice *slice, QPieLegendMarker *q) :
+                QLegendMarkerPrivate(q),
+                m_series(series),
+                m_slice(slice)
             {
+                qDebug() << "QPieLegendMarkerPrivate created";
+                updated();
             }
             QPieLegendMarkerPrivate::~QPieLegendMarkerPrivate()
             {
             }
+            void QPieLegendMarkerPrivate::updated()
+            {
+                m_item->setBrush(m_slice->brush());
+                m_item->setLabel(m_slice->label());
+            }
             #include "moc_qpielegendmarker.cpp"
             #include "moc_qpielegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qpielegendmarker.h +4 -6

             /****************************************************************************
             **
             ** 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 QPIELEGENDMARKER_H
             #define QPIELEGENDMARKER_H
             #include <QChartGlobal>
             #include <QLegendMarker>
             #include <QPieSlice>
             #include "qpielegendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QPieLegendMarker : public QLegendMarker
             {
                 Q_OBJECT
             public:
                 explicit QPieLegendMarker(QPieSeries* series, QPieSlice* slice, QObject *parent = 0);
+                virtual QAbstractSeries* series();
                 virtual QPieSlice* peerObject();
-            // TODO: to pimpl.
+            protected:
-                void updated();
+                QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent = 0);
             //Q_SIGNALS:
             //public Q_SLOTS:
             private:
-                QScopedPointer<QPieLegendMarkerPrivate> d_ptr;
+                Q_DECLARE_PRIVATE(QPieLegendMarker)
                 Q_DISABLE_COPY(QPieLegendMarker)
-            // TODO: PIMPL
-                QPieSlice* m_slice;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIELEGENDMARKER_H

src/legend/qpielegendmarker_p.h +10 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** 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 QPIELEGENDMARKER_P_H
             #define QPIELEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
+            #include <QPieSeries>
+            #include <QPieSlice>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieLegendMarker;
             class QPieLegendMarkerPrivate : public QLegendMarkerPrivate
             {
                 Q_OBJECT
             public:
-                explicit QPieLegendMarkerPrivate(QAbstractSeries *series, QPieLegendMarker *q);
+            //    explicit QPieLegendMarkerPrivate(QAbstractSeries *series, QPieLegendMarker *q);
+                explicit QPieLegendMarkerPrivate(QPieSeries *series, QPieSlice *slice, QPieLegendMarker *q);
                 virtual ~QPieLegendMarkerPrivate();
             public Q_SLOTS:
-                virtual void updated() {};
+                virtual void updated();
             private:
                 QPieLegendMarker *q_ptr;
-                PieLegendMarkerItem *m_item;
+                QPieSeries* m_series;
+                QPieSlice* m_slice;
                 friend class QLegendPrivate; // TODO: Is this needed?
                 Q_DECLARE_PUBLIC(QPieLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIELEGENDMARKER_P_H

src/piechart/qpieseries.cpp +2 -2

             /****************************************************************************
             **
             ** 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 "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "legendmarker_p.h"
             #include "qabstractaxis.h"
             #include "pieanimation_p.h"
             #include "qpielegendmarker.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} or \l {DonutChart Example} {donut chart example} to learn how to use QPieSeries.
                 \table 100%
                 \row
                 \o \image examples_piechart.png
                 \o \image examples_donut.png
                 \endtable
             */
             /*!
                 \qmlclass PieSeries QPieSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple pie chart.
                 \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image demos_qmlchart1.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \qmlproperty real PieSeries::horizontalPosition
                 Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \qmlproperty real PieSeries::verticalPosition
                 Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 When setting this property the holeSize property is adjusted if necessary, to ensure that the hole size is not greater than the outer size.
                 Default value is 0.7.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::holeSize
                 \brief Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.0.
             */
             /*!
                 \qmlproperty real PieSeries::holeSize
                 Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 When setting this property the size property is adjusted if necessary, to ensure that the inner size is not greater than the outer size.
                 Default value is 0.0.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \qmlsignal PieSeries::onCountChanged()
                 Emitted when the slice count has changed.
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \qmlsignal PieSeries::onSumChanged()
                 Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                 change value of a slice.
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
               \qmlsignal PieSeries::onClicked(PieSlice slice)
               This signal is emitted when a \a slice has been clicked.
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                 over the slice and false when hover has moved away from the slice.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successful, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent)
                 : QAbstractSeries(*new QPieSeriesPrivate(this), parent)
             {
                 Q_D(QPieSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice *slice)
             {
                 return append(QList<QPieSlice *>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successful.
             */
             bool QPieSeries::append(QList<QPieSlice *> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice *s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                 }
                 foreach (QPieSlice *s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach(QPieSlice * s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries &QPieSeries::operator << (QPieSlice *slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice *QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice *slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successful.
             */
             bool QPieSeries::insert(int index, QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit added(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successful.
             */
             bool QPieSeries::remove(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Takes a single \a slice from the series. Does not destroy the slice object.
                 NOTE: The series remains as the slice's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QPieSeries::take(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 QPieSlicePrivate::fromSlice(slice)->m_series = 0;
                 slice->disconnect(d);
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice *> slices = d->m_slices;
                 foreach (QPieSlice *s, d->m_slices)
                     d->m_slices.removeOne(s);
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
                 foreach (QPieSlice *s, slices)
                     delete s;
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice *> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setHoleSize(qreal holeSize)
             {
                 Q_D(QPieSeries);
                 holeSize = qBound((qreal)0.0, holeSize, (qreal)1.0);
                 d->setSizes(holeSize, qMax(d->m_pieRelativeSize, holeSize));
             }
             qreal QPieSeries::holeSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_holeRelativeSize;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 relativeSize = qBound((qreal)0.0, relativeSize, (qreal)1.0);
                 d->setSizes(qMin(d->m_holeRelativeSize, relativeSize), relativeSize);
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Sets the all the slice labels \a position
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label position is LabelOutside
                 \sa QPieSlice::labelPosition(), QPieSlice::setLabelPosition()
             */
             void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelPosition(position);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_holeRelativeSize(0.0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice *s, m_slices)
                     sum += s->value();
                 if (!qFuzzyIsNull(m_sum - sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice *> changed;
                 foreach (QPieSlice *s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize)
             {
                 bool changed = false;
                 if (!qFuzzyIsNull(m_holeRelativeSize - innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
                 if (!qFuzzyIsNull(m_pieRelativeSize - outerSize)) {
                     m_pieRelativeSize = outerSize;
                     changed = true;
                 }
                 if (changed)
                     emit pieSizeChanged();
             }
             QPieSeriesPrivate *QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::scaleDomain(Domain &domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             ChartElement *QPieSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem *pie = new PieChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     pie->setAnimation(new PieAnimation(pie));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker *> QPieSeriesPrivate::createLegendMarker(QLegend *legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker *> markers;
                 foreach (QPieSlice *slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q, slice, legend);
                     markers << marker;
                 }
                 return markers;
             }
             QList<QLegendMarker*> QPieSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
-                Q_UNUSED(legend);
+            //    Q_UNUSED(legend);
                 Q_Q(QPieSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
-                    QPieLegendMarker* marker = new QPieLegendMarker(q,slice);
+                    QPieLegendMarker* marker = new QPieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.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